阻塞队列通过互斥锁和条件变量实现线程安全的共享数据，使用wait避免虚假唤醒，notify及时通知对方线程，确保生产者和消费者在队列满或空时正确阻塞与唤醒。

在多线程编程中，线程之间经常需要安全地共享数据。阻塞队列是一种常见的线程同步机制，当队列为空时，消费者线程会被阻塞，直到生产者放入新元素；当队列满时，生产者也会被阻塞，直到有空间可用。C++11 提供了 std::mutex 和 std::condition_variable 来实现这一功能。

基本原理

阻塞队列的核心是保护共享资源（如 std::queue）不被多个线程同时访问。通过互斥锁保证原子性，条件变量用于线程间通信：

• 使用 std::unique_lock<:mutex> 管理锁的生命周期
• 使用 std::condition_variable::wait() 让线程等待特定条件成立
• 使用 notify_one() 或 notify_all() 唤醒等待中的线程

实现一个简单的阻塞队列

下面是一个固定容量的阻塞队列模板实现：

C++ Code Review Master

组合式C++代码评审方案，融合静态分析、AI推理、多轮迭代评审和C++专项检查，适用于PR审查、增量代码审查、全项目评审和代码质量评分，触发词包括review cpp、cpp代码评审、C++review、代码审查。

下载

#include <queue>
#include <mutex>
#include <condition_variable>
#include <chrono>

template <typename T>
class BlockingQueue {
private:
    std::queue<T> data_queue_;
    std::mutex mtx_;
    std::condition_variable not_full_;
    std::condition_variable not_empty_;
    size_t capacity_;

public:
    explicit BlockingQueue(size_t cap = 1000) : capacity_(cap) {}

    void put(const T& item) {
        std::unique_lock<std::mutex> lock(mtx_);
        // 等待队列不满
        not_full_.wait(lock, [this] { return data_queue_.size() < capacity_; });
        data_queue_.push(item);
        not_empty_.notify_one(); // 通知消费者
    }

    void take(T& item) {
        std::unique_lock<std::mutex> lock(mtx_);
        // 等待队列不空
        not_empty_.wait(lock, [this] { return !data_queue_.empty(); });
        item = data_queue_.front();
        data_queue_.pop();
        not_full_.notify_one(); // 通知生产者
    }

    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++免费学习笔记（深入）”；

#include <iostream>
#include <thread>

int main() {
    BlockingQueue<int> queue(5);

    auto producer = [&]() {
        for (int i = 0; i < 10; ++i) {
            queue.put(i);
            std::cout << "Produced: " << i << "\n";
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
    };

    auto consumer = [&]() {
        int value;
        for (int i = 0; i < 10; ++i) {
            queue.take(value);
            std::cout << "Consumed: " << value << "\n";
        }
    };

    std::thread t1(producer);
    std::thread t2(consumer);

    t1.join();
    t2.join();

    return 0;
}

关键点说明

阻塞队列实现中几个重要细节：

• wait 的用法：传入 lambda 表达式作为谓词，避免虚假唤醒问题
• notify 的时机：每次 pop 后通知 not_full_，每次 push 后通知 not_empty_
• 锁的粒度：尽量缩小临界区，只在访问共享队列时加锁
• 异常安全：使用 RAII 类型的锁管理对象（如 unique_lock）

基本上就这些。这种模式广泛应用于任务调度、生产者-消费者系统等场景。