C++怎么实现一个阻塞队列_C++多线程同步与生产者消费者模型

新闻中心 NEWS CENTER

您当前位置：首页 > 新闻中心 > 网络学院

C++怎么实现一个阻塞队列_C++多线程同步与生产者消费者模型

2025-11-20

浏览次数：次

返回列表

阻塞队列通过mutex和condition_variable实现线程同步，1. 使用std::queue存储数据，std::mutex保护共享访问，std::condition_variable实现生产者与消费者间的等待与通知机制；2. put()方法在队列满时阻塞生产者，插入后唤醒消费者；take()方法在队列空时阻塞消费者，取出后唤醒生产者；3. 示例中多线程生产者与消费者通过阻塞队列协调执行，避免竞态条件；4. 注意事项包括避免死锁、使用RAII锁管理、防止虚假唤醒、及时通知及保证异常安全。

c++怎么实现一个阻塞队列_c++多线程同步与生产者消费者模型

在C++多线程编程中，阻塞队列是实现生产者-消费者模型的关键工具。它允许一个或多个线程向队列添加数据（生产者），同时允许其他线程从队列取出数据（消费者），当队列为空时，消费者自动等待；当队列为满时，生产者也自动等待。这种机制依赖于线程同步技术来避免竞态条件和资源冲突。

阻塞队列的基本原理

阻塞队列的核心是“阻塞”行为：当消费者尝试从空队列取数据时，线程会被挂起，直到有新数据入队；同样，如果队列容量有限且已满，生产者入队操作也会被阻塞，直到有空间可用。

实现这一机制需要以下组件：

std::queue：用于存储数据的容器
std::mutex：保护共享队列，防止多线程同时访问
std::condition_variable：用于线程间通信，通知等待中的线程数据已就绪或空间已释放

使用标准库实现阻塞队列

下面是一个基于STL的简单阻塞队列模板实现，支持最大容量限制：

#include <queue>
#include <mutex>
#include <condition_variable>
#include <thread>
<p>template<typename T>
class BlockingQueue {
private:
std::queue<T> data_queue;
mutable std::mutex mtx;
std::condition_variable not_empty;
std::condition_variable not_full;
size_t max_size;</p><p>public:
explicit BlockingQueue(size_t max = 1000) : max_size(max) {}</p><pre class='brush:php;toolbar:false;'>void put(T item) {
    std::unique_lock<std::mutex> lock(mtx);
    not_full.wait(lock, [this]{ return data_queue.size() < max_size; });
    data_queue.push(std::move(item));
    not_empty.notify_one();
}

T take() {
    std::unique_lock<std::mutex> lock(mtx);
    not_empty.wait(lock, [this]{ return !data_queue.empty(); });
    T value = std::move(data_queue.front());
    data_queue.pop();
    not_full.notify_one();
    return value;
}

bool empty() const {
    std::lock_guard<std::mutex> lock(mtx);
    return data_queue.empty();
}

size_t size() const {
    std::lock_guard<std::mutex> lock(mtx);
    return data_queue.size();
}

};

说明：

小云雀

剪映出品的AI视频和图片创作助手

1949 查看详情小云雀

put() 方法在插入前等待队列不满，插入后唤醒可能阻塞的消费者
take() 方法在队列为空时阻塞，获取元素后唤醒可能阻塞的生产者
使用 std::unique_lock 配合 condition_variable::wait() 实现条件等待
使用 std::move 提升性能，避免不必要的拷贝

生产者-消费者模型示例

下面是一个使用上述阻塞队列的简单多线程示例：

#include <iostream>
<p>void producer(BlockingQueue<int>& queue, int id) {
for (int i = 0; i < 5; ++i) {
int item = id * 100 + i;
queue.put(item);
std::cout << "Producer " << id << " put: " << item << "\n";
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}</p><p>void consumer(BlockingQueue<int>& queue, int id) {
for (int i = 0; i < 5; ++i) {
int item = queue.take();
std::cout << "Consumer " << id << " got: " << item << "\n";
std::this_thread::sleep_for(std::chrono::milliseconds(150));
}
}</p><p>int main() {
BlockingQueue<int> queue(10);</p><pre class='brush:php;toolbar:false;'>std::thread p1(producer, std::ref(queue), 1);
std::thread p2(producer, std::ref(queue), 2);
std::thread c1(consumer, std::ref(queue), 1);
std::thread c2(consumer, std::ref(queue), 2);

p1.join();
p2.join();
c1.join();
c2.join();

return 0;