阻塞队列通过std::queue、std::mutex和std::condition_variable实现线程安全的生产者-消费者模型，支持固定容量下的阻塞插入与取出操作。
在多线程编程中，阻塞队列是一种常用的线程安全数据结构，用于生产者-消费者模型。当队列为空时，消费者线程会被阻塞，直到有新元素加入；当队列为满时，生产者线程会被阻塞，直到有空间可用。C++ 中可以通过 std::queue、std::mutex、std::condition_variable 来实现一个高效的阻塞队列。
基本组件说明
要实现一个阻塞队列，需要以下几个关键组件：
- std::queue<T>：用于存储数据的底层容器。
- std::mutex：保护共享队列，防止多个线程同时访问造成数据竞争。
- std::condition_variable：用于线程间通信，实现阻塞与唤醒机制。
- 最大容量（可选）：限制队列大小，实现有界阻塞队列。
阻塞队列类实现
以下是一个线程安全的、固定容量的阻塞队列实现：
立即学习“C++免费学习笔记（深入）”；
#include <queue>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <iostream>
<p>template <typename T>
class BlockingQueue {
private:
std::queue<T> data_queue;
std::mutex mtx;
std::condition_variable not_empty;
std::condition_variable not_full;
size_t max_size;</p><p>public:
explicit BlockingQueue(size_t capacity) : max_size(capacity) {}</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();
}};
使用示例
下面是一个简单的生产者-消费者模型演示：
立即学习“C++免费学习笔记（深入）”；
int main() {
BlockingQueue<int> queue(5); // 容量为5
<pre class='brush:php;toolbar:false;'>auto producer = [&](int id) {
for (int i = 0; i < 10; ++i) {
queue.put(i * 10 + id);
std::cout << "Producer " << id << " put: " << i*10+id << "\n";
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
};
auto consumer = [&]() {
for (int i = 0; i < 20; ++i) {
int value = queue.take();
std::cout << "Consumer got: " << value << "\n";
std::this_thread::sleep_for(std::chrono::milliseconds(50));
}
};
std::thread p1(producer, 1);
std::thread p2(producer, 2);
std::thread c(consumer);
p1.join();
p2.join();
c.join();
return 0;}
该示例创建了两个生产者线程和一个消费者线程，通过阻塞队列安全地传递数据。
关键点总结
实现阻塞队列时需要注意以下几点：
- 使用 std::unique_lock 配合 condition_variable，因为 wait() 需要可释放的锁。
- 条件变量的等待必须使用谓词（lambda），防止虚假唤醒。
- 每次修改队列后，调用 notify_one() 唤醒一个等待线程，提升效率。
- 对 front/pop 的操作必须在锁保护下进行，确保原子性。
- 使用 move 语义减少拷贝开销，提高性能。
基本上就这些。这个实现适用于大多数常见的生产者-消费者场景，可根据需要扩展超时操作（如 try_put/take_with_timeout）。
