线程安全队列

最新推荐文章于 2025-06-24 00:25:55 发布
最新推荐文章于 2025-06-24 00:25:55 发布
阅读量777 收藏 2
点赞数
分类专栏： c++
博客内容包含线程安全队列头文件 thread_safe_queue.h 和测试文件 test.c，涉及信息技术领域的代码文件相关内容。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

// thread_safe_queue.h

#ifndef THREAD_SAFE_QUEUE_H
#define THREAD_SAFE_QUEUE_H

#include <string>
#include <memory>
#include <mutex>
#include <atomic>
#include <sstream>
#include <iostream>
#include <condition_variable>

template<typename T>
class ThreadSafeQueue {
    private:
        struct node {
            std::shared_ptr<T> data;
            std::shared_ptr<node> next;
        };

        std::mutex head_mutex_;
        std::shared_ptr<node> head_;
        std::mutex tail_mutex_;
        std::shared_ptr<node> tail_;
        std::condition_variable data_cond_;
        std::atomic<int> size_;

    public:
        ThreadSafeQueue(): head_(new node), tail_(head_), size_(0) {}
        ThreadSafeQueue(const ThreadSafeQueue& other) = delete;
        ThreadSafeQueue& operator=(const ThreadSafeQueue& other) = delete;

        bool empty();
        void push(T new_value);
        void push(std::shared_ptr<T> new_value_ptr);
        bool try_pop(T& value);
        std::shared_ptr<T> try_pop();
        bool wait_and_pop(T& value);
        std::shared_ptr<T> wait_and_pop();

        int size() {return size_; };
        std::string debug_info();

    private:
        std::shared_ptr<node> get_tail() {
            std::lock_guard<std::mutex> tail_lock(tail_mutex_);
            return tail_;
        }
        std::shared_ptr<node> pop_head() {
            std::shared_ptr<node> old_head = head_;
            head_ = old_head->next;
            size_--;
            return old_head;
        }
        std::unique_lock<std::mutex> wait_for_data() {
            std::unique_lock<std::mutex> head_lock(head_mutex_);
            data_cond_.wait(head_lock, [&]{return head_!=get_tail();});
            return std::move(head_lock);
        }
        std::shared_ptr<node> wait_pop_head() {
            std::unique_lock<std::mutex> head_lock(wait_for_data());
            return pop_head();
        }
        std::shared_ptr<node> wait_pop_head(T& value) {
            std::unique_lock<std::mutex> head_lock(wait_for_data());
            value = std::move(*head_->data);
            return pop_head();
        }
        std::shared_ptr<node> try_pop_head() {
            std::lock_guard<std::mutex> head_lock(head_mutex_);
            if (head_ == get_tail()) {
                return std::shared_ptr<node>();
            }
            return pop_head();
        }
        std::shared_ptr<node> try_pop_head(T& value) {
            std::lock_guard<std::mutex> head_lock(head_mutex_);
            if (head_ == get_tail()) {
                return std::shared_ptr<node>();
            }
            value = std::move(*head_->data);
            return pop_head();
        }
};

template<typename T>
bool ThreadSafeQueue<T>::empty() {
    std::lock_guard<std::mutex> head_lock(head_mutex_);
    return (head_==get_tail());
}

template<typename T>
void ThreadSafeQueue<T>::push(T new_value) {
    std::shared_ptr<T> new_data(std::make_shared<T>(std::move(new_value)));
    push(new_data);
}

template<typename T>
void ThreadSafeQueue<T>::push(std::shared_ptr<T> new_data) {
    std::shared_ptr<node> new_tail(new node);
    {
        std::lock_guard<std::mutex> tail_lock(tail_mutex_);
        tail_->data = new_data;
        tail_->next = new_tail;
        tail_ = new_tail;
        size_++;
    }
    data_cond_.notify_one();
}

template<typename T>
bool ThreadSafeQueue<T>::try_pop(T& value) {
    std::shared_ptr<node> old_head = try_pop_head(value);
    return old_head;
}

template<typename T>
std::shared_ptr<T> ThreadSafeQueue<T>::try_pop() {
    std::shared_ptr<node> old_head = try_pop_head();
    return old_head? old_head->data: std::shared_ptr<T>();
}

template<typename T>
bool ThreadSafeQueue<T>::wait_and_pop(T& value) {
    std::shared_ptr<node> const old_head = wait_pop_head(value);
}

template<typename T>
std::shared_ptr<T> ThreadSafeQueue<T>::wait_and_pop() {
    std::shared_ptr<node> const old_head = wait_pop_head();
    return old_head->data;
}

template<typename T>
std::string ThreadSafeQueue<T>::debug_info() {
    std::ostringstream oss;
    std::unique_lock<std::mutex> lock_head(head_mutex_, std::defer_lock);
    std::unique_lock<std::mutex> lock_tail(tail_mutex_, std::defer_lock);
    std::lock(lock_head, lock_tail);

    std::shared_ptr<node> p = head_;
    int num = 0;
    int num_limit = 100;
    bool cross_limit = false;
    oss << "size[" << size() << "]  ";
    oss  << "[head] -> ";
    while (p && p->data) {
        if (++num <= num_limit) {
            oss << *p->data << " -> ";
            if (num % 20 == 0) {
                oss << std::endl;
            }
        } else {
            if (!cross_limit) {
                cross_limit = true;
                oss << "... ..." << " -> ";
            }
        }
        p = p->next;
    }
    oss << "[tail]" << "  [" << num << "]";
    if (num != size()) {
        oss << " [error: num do not match size]";
    }

    return oss.str();
}

#endif /* THREAD_SAFE_QUEUE_H */

// test.c

#include "thread_safe_queue.h"

int main() {
    ThreadSafeQueue<std::string> myQueue;
    myQueue.push("001");
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.push("002");
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.push("003");
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.push("004");
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.push("005");
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.push("006");
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.push("007");
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.push("008");
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.push("009");
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.push("010");
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.wait_and_pop();
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.wait_and_pop();
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.wait_and_pop();
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.wait_and_pop();
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.wait_and_pop();
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.wait_and_pop();
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.wait_and_pop();
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.wait_and_pop();
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.try_pop();
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.wait_and_pop();
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.try_pop();
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.try_pop();
    std::cout << myQueue.debug_info() << std::endl;
    myQueue.try_pop();
    std::cout << myQueue.debug_info() << std::endl;
    return 0;
}

$ g++ test.cpp -o test && ./test
size[1]  [head] -> 001 -> [tail]  [1]
size[2]  [head] -> 001 -> 002 -> [tail]  [2]
size[3]  [head] -> 001 -> 002 -> 003 -> [tail]  [3]
size[4]  [head] -> 001 -> 002 -> 003 -> 004 -> [tail]  [4]
size[5]  [head] -> 001 -> 002 -> 003 -> 004 -> 005 -> [tail]  [5]
size[6]  [head] -> 001 -> 002 -> 003 -> 004 -> 005 -> 006 -> [tail]  [6]
size[7]  [head] -> 001 -> 002 -> 003 -> 004 -> 005 -> 006 -> 007 -> [tail]  [7]
size[8]  [head] -> 001 -> 002 -> 003 -> 004 -> 005 -> 006 -> 007 -> 008 -> [tail]  [8]
size[9]  [head] -> 001 -> 002 -> 003 -> 004 -> 005 -> 006 -> 007 -> 008 -> 009 -> [tail]  [9]
size[10]  [head] -> 001 -> 002 -> 003 -> 004 -> 005 -> 006 -> 007 -> 008 -> 009 -> 010 -> [tail]  [10]
size[9]  [head] -> 002 -> 003 -> 004 -> 005 -> 006 -> 007 -> 008 -> 009 -> 010 -> [tail]  [9]
size[8]  [head] -> 003 -> 004 -> 005 -> 006 -> 007 -> 008 -> 009 -> 010 -> [tail]  [8]
size[7]  [head] -> 004 -> 005 -> 006 -> 007 -> 008 -> 009 -> 010 -> [tail]  [7]
size[6]  [head] -> 005 -> 006 -> 007 -> 008 -> 009 -> 010 -> [tail]  [6]
size[5]  [head] -> 006 -> 007 -> 008 -> 009 -> 010 -> [tail]  [5]
size[4]  [head] -> 007 -> 008 -> 009 -> 010 -> [tail]  [4]
size[3]  [head] -> 008 -> 009 -> 010 -> [tail]  [3]
size[2]  [head] -> 009 -> 010 -> [tail]  [2]
size[1]  [head] -> 010 -> [tail]  [1]
size[0]  [head] -> [tail]  [0]
size[0]  [head] -> [tail]  [0]
size[0]  [head] -> [tail]  [0]
size[0]  [head] -> [tail]  [0]
c++11 线程池系列之一 所需要的thread_safe_queue
Guyf的专栏
11-28 4280
template class thread_safe_queue { private: mutable std::mutex mut; std::queue> data_queue; std::condition_variable data_con; public: thread_safe_queue(){} thread_safe_queue(thread_safe_queue con
线程安全型队列的实现
01-02
操作系统课程设计线程安全型队列，利用读者优先机制实现互斥。
实现一个线程安全的Queue队列
weixin_30912051的博客
09-02 437
使用装饰者模式实现一个线程安全的Queue队列。 public class SynchronizedQueue<E> implements Queue<E>, Serializable { private static final long serialVersionUID = -1439242290701194806L; private final Queue&lt...
BlockingQueue深度解析
最新发布
csdn_tom_168的博客
06-24 830
本文深度解析了Java并发包（JUC）中的BlockingQueue。BlockingQueue是线程安全阻塞队列，提供多种操作模式，支持有界/无界配置。主要实现类包括ArrayBlockingQueue（基于循环数组）、LinkedBlockingQueue（基于链表）、PriorityBlockingQueue（基于堆）和SynchronousQueue（直接传递模式）。文章详细分析了各实现类的底层结构、典型场景和使用技巧，并通过基准测试对比了性能差异。在生产者-消费者模式和线程池工作队列等关键场景中，
写一个线程安全的队列
weixin_35755823的博客
01-02 230
你可以使用 Python 中的 Queue 模块中的 Queue 类来创建一个线程安全的队列。这个类在线程间提供了同步机制，使得你可以在多个线程之间安全地使用一个队列。 下面是一个例子，展示了如何使用 Queue 类来创建一个线程安全的队列： import queue q = queue.Queue() # 在队列中添加一个元素 q.put('a') # 从队列中取出一个元素 item = ...
C++实现线程安全队列
05-14
使用互斥变量技术完成C++安全队列，同时编写测试代码进行此队列的测试。
SafeQueue:C++ 中的线程安全队列实现
05-30
安全队列 这个类是一个多生产者、多消费者队列。 它同时提供阻塞和非阻塞消费，而生产总是阻塞。 容量是动态调整的。 实现基于std::queue ，使用std::mutex和std::condition_variable实现线程安全。 可以使用右值引用调用Produce(T&& item)函数。 Consume(T& item)函数立即返回一个布尔值，表示成功。 ConsumeSync(T& item)方法将阻塞调用线程，直到它可以从队列中取出一个项目。 Finish方法停止所有等待的消费者 (ConsumeSync)，并使它们返回 false。 例子 制作人： SafeQueue<MyType> queue; // insert elements queue.Produce(std::move(var1)); queue.Produce(std::move(var2)); 非阻塞消费
实现线程安全的队列
hanhan的博客
06-13 2752
使用了互斥量和条件变量来保证线程安全。中推入了 10 个整数，每个整数之间间隔 100 毫秒。假设我们忽略构造、赋值、互换、拷贝，那么只剩下3组操作。中取出了 10 个整数，并输出了每个整数的值。2：front、back，用于查询队列中的元素。在这个示例代码中，我们定义了一个生产者函数。中推入数据和从中取出数据。，并在两个线程中分别调用。
线程安全的队列实现
weixin_41157881的博客
08-07 392
#include #include #include #include <condition_variable> template class threadsafe_queue { public: threadsafe_queue() {} ~threadsafe_queue() {} void push(T new_data) { std::lock_guard<s...
线程安全的队列实现（CAS与锁）
much efforts, much luck
08-20 1270
数组实现线程安全的循环队列 cas函数如下：bool succ = __sync_bool_compare_and_swap(&a, b, c） //---》 if(a ==b ) {a = c;return true;}else{return false} struct queue{ int data[10000]; int front; int back; }; int maxSize=10000; queue* q; int push(int d){ if ((q->bac
java threadsafequeue_<Web Crawler><Java><thread-safe queue>
weixin_27960253的博客
02-13 186
Basic SolutionThe simplest way is to build a web crawler that runs on a single machine with single thread.So, a basic web crawler should be like this:Start with a URL pool that contains all the websit...
手写一个线程安全的非阻塞队列，并且实现入队出队方法
12-22
实现思路：利用单向链表来保存队列的数据，在往队列中添加元素的时候，新建一个节点，加入到队尾，加入到队尾的操作，利用CAS原理加乐观锁，另外，还需要将新加的节点设置为新的队尾，此步操作也需要利用CAS，head与tail变量用volatile修饰，保证多线程环境下的线程可见性。 相关代码如下： import sun.misc.Unsafe; import java.lang.reflect.Field; public class MyLinkQueue { //头节点 private volatile Node head; //尾节点 private volati
CThreadSafeQueue.rar
08-07
本资源是有关线程安全的队列类的应用，使用了C++11中的几个类，和传统的队列Queue中加一个锁进行多线程数据共享比较，速度快很多，在多并发线程处理中会应用到。
使用 Java 构造高可扩展应用,如何实现一个高效且多线程安全的队列
02-24 1798
 为什么性能没有增长？多核能带来性能的大幅增长，这很容易通过简单的一些测试来观察到。如果我们写一个多线程程序，并在每个线程中对一个本地变量进行累加，我们可以很容易的看到多核和并行带来的成倍的性能提升。这非常容易做到，不是吗？在 参考资源 里我们给出了一个例子。然而，与我们的测试相反，我们很少在实际软件应用中看到这样完美的可扩展性。阻碍我们获得完美的可扩展性有两方面的因素存在。首先，我们面临
java threadsafequeue_【Java】ThreadSafeQueue
weixin_39967598的博客
02-13 157
import java.util.Collection;import java.util.Iterator;import java.util.LinkedList;import java.util.Queue;import java.util.Spliterator;import java.util.concurrent.locks.ReadWriteLock;import java.util.c...
【Java】ThreadSafeQueue
XKIND'S 博客
03-13 589
import java.util.Collection; import java.util.Iterator; import java.util.LinkedList; import java.util.Queue; import java.util.Spliterator; import java.util.concurrent.locks.ReadWriteLock; import java....
实现线程安全的队列Queue（Python）
热门推荐
HenryLei的博客
08-18 2万+
关于队列 用于存放多个元素，是存放各种元素的“池”。 实现的基本功能 获取当前队列元素数量-->往队列放入元素-->往队列取出元素。 注意 队列可能有多个线程同时操作，因此需要保证线程安全，如下两种情况： 具体实现 # -*- encoding=utf-8 -*- import time import threa...
Java线程安全队列Queue实现原理
weixin_30809173的博客
07-29 242
原文链接:https://www.cnblogs.com/DreamRecorder/p/9223016.html 在Java多线程应用中，队列的使用率很高，多数生产消费模型的首选数据结构就是队列。Java提供的线程安全的Queue可以分为阻塞队列和非阻塞队列，其中阻塞队列的典型例子是BlockingQueue，非阻塞队列的典型例子是ConcurrentLinkedQueue，在实际...
c++多线程进阶(6): 采用精细粒度的锁和条件变量的threadsafe_queue
TOPEE362的博客
08-11 490
采用精细粒度的锁和条件变量的threadsafe_queue
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值