基于C++11实现的阻塞队列(BlockQueue)

已于 2023-01-05 08:47:38 修改
阅读量3.4k 收藏 33
点赞数 5
分类专栏： webServer 文章标签： c++ 数据结构
于 2022-12-25 15:39:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50437588/article/details/128434180
版权

思路：

生产者消费者模型

 如图，多个生产者线程和多个消费者线程共享同一固定大小的缓冲区，它们的生产和消费符合以下规则：

  • 生产者不会在缓冲区满的时候继续向缓冲区放入数据，而消费者也不会在缓冲区空的时候，消耗数据
  • 当缓冲区满的时候，生产者会进入阻塞状态，当下次消费者开始消耗缓冲区的数据时，生产者才会被唤醒，开始往缓冲区中添加数据；当缓冲区空的时候，消费者也会进入阻塞状态，直到生产者往缓冲区中添加数据时才会被唤醒

所以重点为实现一个线程安全的缓冲队列：

1、首先使用STL库中的deque作为基本容器；

2、然后定义一个固定大小的容量capacity，防止无限制扩容下去导致内存耗尽；

3、之后需要两个条件变量Productor和Consumer，模拟生产者和消费者；

4、条件变量必须得有互斥量辅助，所以还需一个互斥量mutex。 

template<class T>
class BlockQueue {
public:
    explicit BlockQueue(size_t maxCapacity = 1000);
    ~BlockQueue();
private:
    std::deque<T> deq;
    size_t capacity;
    std::mutex mtx;
    std::condition_variable Consumer;
    std::condition_variable Producer;
};

主要成员函数介绍：

1、析构函数：清理队列中的所有成员，唤醒所有阻塞中的生产者、消费者线程。

template<class T>
BlockQueue<T>::~BlockQueue()
{
    {
        std::lock_guard<std::mutex> locker(mtx);
        deq.clear();
    }
    Producer.notify_all();
    Consumer.notify_all();
};

2、生产者线程应该调用的函数

（1）void BlockQueue<T>::push_back(const T& item)

template<class T>
void BlockQueue<T>::push_back(const T& item)
{
    //使用条件变量前应先对互斥量上锁，此时选择unique_lock而非lock_guard
    //因为unique_lock在上锁后允许临时解锁再加锁，而lock_guard上锁后只能在离开作用域时解锁
    std::unique_lock<std::mutex> lock(mtx);
    while (deq.size() >= capacity)
    {
        //若队列已满，则生产者线程进入阻塞状态，自动对互斥量解锁，被唤醒后又自动对互斥量加锁
        Producer.wait(lock);
    }
    deq.push_back(item);//向队列中放入数据
    Consumer.notify_one();//唤醒一个阻塞的消费者线程
}

 （2）void BlockQueue<T>::push_front(const T& item)

template<class T>
void BlockQueue<T>::push_front(const T& item)
{
    std::unique_lock<std::mutex> lock(mtx);
    while (deq.size() >= capacity)
    {
        Producer.wait(lock);
    }
    deq.push_front(item);
    Consumer.notify_one();
}

3、消费者线程应该调用的函数

（1）bool BlockQueue<T>::pop(T& item)

因为要实现线程安全的函数，所以将pop函数的接口设计为需要放入一个自己的T& item作为删除数据的拷贝。 

template<class T>
bool BlockQueue<T>::pop(T& item)
{
    std::unique_lock<std::mutex> lock(mtx);
    while (deq.empty())
    {
        //若队列空，则消费者线程进入阻塞，等待被唤醒
        Consumer.wait(lock);
    }
    item = deq.front();//当作删除数据的拷贝
    deq.pop_front();
    Producer.notify_one();//唤醒一个阻塞的生产者线程
    return true;
}

（2）bool BlockQueue<T>::pop(T& item,int timeout)

为pop()函数添加第二参数timeout，设计为带计时器的pop函数。

若队列在超时时间后仍一直为空，则立刻返回false。

template<class T>
bool BlockQueue<T>::pop(T& item,int timeout)
{
    std::unique_lock<std::mutex> lock(mtx);
    while (deq.empty())
    {
        //阻塞时间超过指定的timeout，直接返回false
        if (Consumer.wait_for(lock, std::chrono::seconds(timeout)) == std::cv_status::timeout)
            return false;
    }
    item = deq.front();
    deq.pop_front();
    Producer.notify_one();
    return true;
}

 4、一些额外的成员函数

（1）判断队列为空 

template<class T>
bool BlockQueue<T>::empty()
{
    std::lock_guard<std::mutex> lock(mtx);
    return deq.empty();
}

（2）判断队列为满

template<class T>
bool BlockQueue<T>::full()
{
    std::lock_guard<std::mutex> lock(mtx);
    return deq.size()>=capacity;
}

（3）模拟队列的front函数

template<class T>
T BlockQueue<T>::front()
{
    std::lock_guard<std::mutex> lock(mtx);
    return deq.front();
}

（4）模拟队列的back函数

template<class T>
T BlockQueue<T>::back()
{
    std::lock_guard<std::mutex> lock(mtx);
    return deq.back();
}

 

源码： 

 blockqueue.h

#ifndef BLOCKQUEUE_H
#define BLOCKQUEUE_H

#include <mutex>
#include <deque>
#include <condition_variable>
#include <assert.h>
#include <chrono>

template<class T>
class BlockQueue {
public:
    explicit BlockQueue(size_t maxCapacity = 1024);

    ~BlockQueue();

    void close();

    void flush();

    void clear();

    T front();

    T back();

    size_t get_size();

    size_t get_capacity();

    void push_back(const T& item);

    void push_front(const T& item);

    bool empty();

    bool full();

    bool pop(T& item);

    bool pop(T& item, int timeout);

private:
    std::deque<T> deq;

    size_t capacity;

    std::mutex mtx;

    bool isClose;

    std::condition_variable Consumer;

    std::condition_variable Producer;
};


template<class T>
BlockQueue<T>::BlockQueue(size_t maxCapacity):capacity(maxCapacity) 
{
    assert(maxCapacity > 0);
    isClose = false;
}

template<class T>
BlockQueue<T>::~BlockQueue()
{
    close();
};

template<class T>
void BlockQueue<T>::close()
{
    {
        std::lock_guard<std::mutex> locker(mtx);
        deq.clear();
        isClose= true;
    }
    Producer.notify_all();
    Consumer.notify_all();
};

template<class T>
void BlockQueue<T>::flush()
{
    Consumer.notify_one();
}

template<class T>
void BlockQueue<T>::clear()
{
    std::lock_guard<std::mutex> lock(mtx);
    deq.clear();
}

template<class T>
T BlockQueue<T>::front()
{
    std::lock_guard<std::mutex> lock(mtx);
    return deq.front();
}

template<class T>
T BlockQueue<T>::back()
{
    std::lock_guard<std::mutex> lock(mtx);
    return deq.back();
}

template<class T>
size_t BlockQueue<T>::get_size()
{
    std::lock_guard<std::mutex> lock(mtx);
    return deq.size();
}

template<class T>
size_t BlockQueue<T>::get_capacity()
{
    std::lock_guard<std::mutex> lock(mtx);
    return capacity;
}

template<class T>
void BlockQueue<T>::push_back(const T& item)
{
    std::unique_lock<std::mutex> lock(mtx);
    while (deq.size() >= capacity)
    {
        Producer.wait(lock);
    }
    deq.push_back(item);
    Consumer.notify_one();
}

template<class T>
void BlockQueue<T>::push_front(const T& item)
{
    std::unique_lock<std::mutex> lock(mtx);
    while (deq.size() >= capacity)
    {
        Producer.wait(lock);
    }
    deq.push_front(item);
    Consumer.notify_one();
}

template<class T>
bool BlockQueue<T>::empty()
{
    std::lock_guard<std::mutex> lock(mtx);
    return deq.empty();
}

template<class T>
bool BlockQueue<T>::full()
{
    std::lock_guard<std::mutex> lock(mtx);
    return deq.size()>=capacity;
}

template<class T>
bool BlockQueue<T>::pop(T& item)
{
    std::unique_lock<std::mutex> lock(mtx);
    while (deq.empty())
    {
        Consumer.wait(lock);
        if (isClose)
            return false;
    }
    item = deq.front();
    deq.pop_front();
    Producer.notify_one();
    return true;
}

template<class T>
bool BlockQueue<T>::pop(T& item,int timeout)
{
    std::unique_lock<std::mutex> lock(mtx);
    while (deq.empty())
    {
        if (Consumer.wait_for(lock, std::chrono::microseconds(timeout)) == std::cv_status::timeout)
            return false;
        if (isClose)
            return false;
    }
    item = deq.front();
    deq.pop_front();
    Producer.notify_one();
    return true;
}

#endif // BLOCKQUEUE_H
{(sunburst)}
关注
  • 5
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
c++11 并发队列的生产方案 BlockingConcurrentQueue
BBinChina的专栏
09-09 1886
ConcurrentQueue 这是我在生产中使用到的一个c++11 实现的无锁队列，有以下特性： 1、线程安全的无锁队列 2、支持c++11 的move语义，优化对象拷贝性能 3、模板化 4、可预分配内存、也可动态分配 5、支持批量处理 6、包含阻塞队列 7、异常安全 demo 将github里的文件 Blockingconcurrentqueue.h 跟 Concurrentqueue.h 加载到项目中 #include "Blockingconcurrentqueue.h" //声明队列 moody
一个c++11实现的无锁队列.zip
11-20
在这个“一个c++11实现的无锁队列”中，我们可以探讨以下几个关键知识点： 1. **无锁编程**：无锁编程是一种并发编程技术，它避免了线程间的竞争条件和死锁问题，通过原子操作保证数据的一致性。在无锁队列中，数据...
阻塞队列BlockingQueue
Al_0922的博客
07-03 193
阻塞队列 阻塞：必须要阻塞、不得不阻塞 阻塞队列有两个附加操作 支持阻塞的插入方法，当队列满时，从队列中插入元素会被阻塞，直至队列不满 支持阻塞的移除方法，当队列为空时，获取元素的线程会等待队列变为非空 试图从空的队列中获取元素的线程将会被阻塞，直到其他的线程往空队列里插入元素。 试图向已满的队列中添加元素的线程将会被阻塞，知道其他线程从已满的队列中移除元素。 应用场景 常用于生产者与消费者模式中，生产者是向队列里添加元素的线程，消费者是向队列里移除元素的线程。简单来说，阻塞队列是生产者用
面试刷题11-13
wwxy1995的博客
11-13 1623
大华8月份投的提前批简历，然后等了快1个月，9月初接到大华一个部门电话，说看重简历上C++项目（本人做Java），然后聊了几下，接着邀约9曰5号去大华面试。9月5号如约而至，果然如网上所说在食堂面试，首先是给1个小时时间做笔试，由于他们是C++客户端方向，试卷全是Linux、C++，还好本人大学及研一做过C++，所以基本能完成。紧接着面试官看过卷子后来面试，一面是关于C++基础的，然后如何优化试卷...
c++ 线程阻塞等待别人激活
最新发布
xie__jin__cheng的博客
05-06 1671
c++ 线程阻塞等待别人激活
使用C++ 11 实现阻塞队列
kwame211的博客
01-01 961
阻塞队列介绍 阻塞队列主要用于线程和线程之间的通信。当队列为空时，从队列中获取元素的线程将会被挂起；当队列是满时，往队列里添加元素的线程将会挂起。 本文使用C++ 11中的多线程库，实现了一个带有最大容量的阻塞队列。代码使用Visual C++ 2015编写。 阻塞队列的实现代码  BlockQueue.hpp [cpp] view plain c
C++实现阻塞队列
weixin_42210846的博客
05-11 815
#ifndef BLCOKING_QUEUE_H #define BLCOKING_QUEUE_H #include <memory> #include <list> #include <mutex> #include <condition_variable> template<typename T> class BlockingQueue { public: BlockingQueue() = default; BlockingQueue
c++实现的阻塞队列
len_yue_mo_fu的博客
05-07 4259
阻塞队列(block_queue) 什么是阻塞队列： 在多线程编程时当有多个线程访问一个队列时如果队列为空，则获取队列中元素的方法就会阻塞，直到队列中有元素可以获取 解决的问题： 队列的线程安全问题 队列多线程取元素时的轮询判断问题 什么情况下需要阻塞队列： 在c++标准库STL中常用的队列容器都不是线程安全的，我们在多线程编程时总会有类似于生产者消费者这种模型，在这种模型下我们访问队列...
利用C++如何实现一个阻塞队列详解
12-16
阻塞队列是多线程中常用的数据结构，对于实现多线程之间的数据交换、同步等有很大作用。 阻塞队列常用于生产者和消费者的场景，生产者是向队列里添加元素的线程，消费者是从队列里取元素的线程。简而言之，阻塞队列是生产者用来存放元素、消费者获取元素的容器。 考虑下，这样一个多线程模型，程序有一个主线程 master 和一些 worker 线程，master 线程负责接收到数据，给 worker 线程分配数据，worker 线程取得一个任务后便可以开始工作，如果没有任务便阻塞住，节约 cpu 资源。 master 线程  （生产者）：负责往阻塞队列中塞入数据，并唤醒正在阻塞的 worker 线程。
阻塞队列之ArrayBlockingQueue源码分析
Niulx
05-22 488
BlockingQueue是一个阻塞队列，在高并发场景应用的非常广泛，最常见的情景应该就是在线程池中，其他的比如在ZooKeeper源码中，dubbo源码中也大量使用了阻塞队列，我们经常使用的也就是ArrayBlockingQueue，LinkedBlockingQueue，SynchronousQueue，ConcurrentLinkedQueue这几种。ArrayBlockingQueueAr...
【多线程/C++】阻塞队列的C++多线程 实现 BlockingQueue
u011754972的博客
06-23 2659
阻塞队列实现： 当队列为空时，从队列获取元素的操作将会被阻塞，直到队列中被放入了元素； 当队列满时，有两种方案： 方案1： 往队列里存放元素的操作也会被阻塞，直到有元素被从队列中取出或者删除。 具体方法：定义一个条件变量std::condition_variable not_full_;在存放操作时，判断队列为满时,使用not_full_.wait(lock)阻塞线程；当进行删除队列元素的操作后，就使用not_full_.notify_all()来唤醒not_full_.wait(lock)
阻塞队列(BlockingQueue)详解
qq_45263049的博客
09-09 480
阻塞队列是Java并发编程中非常重要的一个工具类，它可以实现多线程之间的协作，提高程序的效率和可靠性
C++11 实现简单的阻塞队列
好习惯成就伟大
09-08 730
一个blocking queue是一个支持 take 和 put 的 queue。 take操作从队列中取出一个元素，如果队列为空，那么take会阻塞到直到队列中有可用元素。 put操作往队列里放入一个元素，如果队列是满，那么put会阻塞到队列有可用空间。 一个简单的blocking queue的实现，首先我们要有一个非常底层的容器，至于是vector还是deque甚至是list都无所谓，我们这里选择deque作为容器。 前面定义的blocking queue是有界的，也就是说元素有上限，所以才会出
c++11 实现的阻塞队列
05-17
C++11 实现的阻塞队列 C++11 中的阻塞队列是指在多线程环境下，实现生产者消费者模式的队列。阻塞队列的实现需要解决两个问题：线程安全和阻塞机制。在 C++11 中，我们可以使用 std::mutex、std::condition_...
c++实现的无锁环形队列
11-05
1. c++实现的无锁环形队列，注释详细，讲解了环形队列的实现原理和操作技巧 2. 在linux服务器下，可以自己编译，运行，也可以修改参数后做测试 3. 编译的命令如下：g++ -std=c++11 -o test main.cpp ring_buffer.cpp...
Linux C++ 使用condition实现阻塞队列的方法
09-15
在这个例子中，我们看到如何在Linux环境下使用C++和POSIX线程库(pthread)中的条件变量(condition variables)来实现阻塞队列。 首先，我们需要包含必要的头文件，并定义一个名为`BlockingQueue`的类。这个类包含了...
c++11无锁队列的一种简单实现.pptx
03-08
在C++11中，无锁队列的实现主要依赖于新标准引入的多线程支持、原子操作和内存模型。 首先，我们来看C++11的多线程支持。`<thread>`头文件提供了`std::thread`类，使得我们可以创建和管理线程。`std::this_thread`...
多线程进阶（六）-- 阻塞队列BlockingQueue
weixin_39724194的博客
07-19 618
队列Queue： 队列，是一种数据结构。除了优先级队列和LIFO队列外，队列都是以FIFO（先进先出）的方式对各个元素进行排序的。无论使用哪种排序方式，队列的头都是调用remove()或poll()移除元素的。在FIFO队列中，所有新元素都插入队列的末尾。 Queue中的方法： Queue中的方法不难理解，6个，每2对是一个也就是总共3对。看一下JDK API就知道了： 注意一点就好，Queue通常不允许插入Null，尽管某些实现（比如LinkedList）是允许的，但是也不建议。 阻塞队列Blockin
基于C++11的阻塞队列简单实现
844604778
06-23 507
基于C++11的阻塞队列简单实现 转载请说明出处：http://blog.csdn.net/cywosp/article/details/9157379 在多线程编程中阻塞队列(Blocking Queue)是一种常用于实现生产者和消费者模型的数据结构。其与普通的队列区别在于，当队列为空时，从队列获取元素的操作将会被阻塞，直到队列中被放入了元素；当队列满时，往队列里存放元素的操作也会被...
基于std::queue c++11 线程安全队列
08-09
std::queue是C++标准库中的队列容器，它不是线程安全的。在多线程环境下使用std::queue可能会导致数据竞争和问题。 为了保证线程安全，可以对std::queue进行适当的封装或使用其他已经实现好的线程安全队列。C++11中引入了std::queue的线程安全版本std::queue。 std::queue的线程安全版本可以通过使用互斥锁(mutex)来保护队列的访问。互斥锁可以确保同一时间只有一个线程访问队列，避免了数据竞争。 以下是一个基于std::queue的线程安全队列的示例： ```cpp #include <queue> #include <mutex> template <typename T> class ThreadSafeQueue { public: ThreadSafeQueue() {} void push(const T& value) { std::lock_guard<std::mutex> lock(mutex_); queue_.push(value); } bool pop(T& value) { std::lock_guard<std::mutex> lock(mutex_); if (queue_.empty()) return false; value = queue_.front(); queue_.pop(); return true; } bool empty() const { std::lock_guard<std::mutex> lock(mutex_); return queue_.empty(); } size_t size() const { std::lock_guard<std::mutex> lock(mutex_); return queue_.size(); } private: std::queue<T> queue_; mutable std::mutex mutex_; }; ``` 上述代码中，通过std::mutex实现了对队列的互斥访问，使得push、pop、empty和size等操作变得线程安全。 基于std::queue的线程安全队列可以在多线程环境下安全地进行数据操作，避免了数据竞争的问题，提高了程序的稳定性和可靠性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值