阻塞队列通过mutex和condition_variable实现线程同步，1. 使用std::queue存储数据，std::mutex保护共享访问，std::condition_variable实现生产者与消费者间的等待与通知机制；2. put()方法在队列满时阻塞生产者，插入后唤醒消费者；take()方法在队列空时阻塞消费者，取出后唤醒生产者；3. 示例中多线程生产者与消费者通过阻塞队列协调执行，避免竞态条件；4. 注意事项包括避免死锁、使用RAII锁管理、防止虚假唤醒、及时通知及保证异常安全。
在C++多线程编程中，阻塞队列是实现生产者-消费者模型的关键工具。它允许一个或多个线程向队列添加数据（生产者），同时允许其他线程从队列取出数据（消费者），当队列为空时，消费者自动等待；当队列为满时，生产者也自动等待。这种机制依赖于线程同步技术来避免竞态条件和资源冲突。
阻塞队列的基本原理
阻塞队列的核心是“阻塞”行为：当消费者尝试从空队列取数据时，线程会被挂起，直到有新数据入队；同样，如果队列容量有限且已满，生产者入队操作也会被阻塞，直到有空间可用。
实现这一机制需要以下组件：
- std::queue：用于存储数据的容器
- std::mutex：保护共享队列，防止多线程同时访问
- std::condition_variable：用于线程间通信，通知等待中的线程数据已就绪或空间已释放
使用标准库实现阻塞队列
下面是一个基于STL的简单阻塞队列模板实现，支持最大容量限制：
立即学习“C++免费学习笔记（深入）”；
#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();
}};
说明：
-
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;}
输出会显示生产者和消费者交错执行，即使生产和消费速度不同，也能通过阻塞机制自动协调。
关键注意事项
在实际使用中需要注意几点：
- 避免死锁：确保每次加锁都有对应的解锁，优先使用RAII风格的锁管理（如
std::lock_guard、std::unique_lock） - 条件变量必须配合循环检查：虽然
wait()使用了谓词，但为防止虚假唤醒，内部仍会做循环判断 - 及时通知：每次状态改变（入队/出队）都应调用
notify_one()或notify_all() - 异常安全：考虑在构造函数可能抛异常的情况下，保持队列的一致性
基本上就这些。C++标准库提供了足够强大的工具来构建高效的阻塞队列，理解其同步机制对编写稳定多线程程序至关重要。
