C++如何实现一个阻塞队列_C++并发队列设计与阻塞机制实现

阻塞队列是C++生产者-消费者模型的核心，通过互斥锁与条件变量实现线程安全和阻塞操作，支持有界/无界队列设计，配合wait、notify机制协调生产与消费，避免竞争与资源浪费。

在C++多线程编程中，阻塞队列是实现生产者-消费者模型的关键组件。它允许多个线程安全地共享数据，当队列为空时，消费者线程自动等待；当队列满时，生产者线程等待，直到有空间可用。这种机制能有效避免资源浪费和竞争条件。

阻塞队列的基本设计思路

一个阻塞队列需要满足以下几点：

• 线程安全：多个线程可以同时访问队列而不导致数据竞争
• 阻塞操作：取元素时若队列为空，则调用线程应被阻塞；插入时若队列满，则阻塞直到有空间
• 可配置容量：支持有界队列（固定大小）或无界队列

核心依赖是互斥锁（std::mutex）和条件变量（std::condition_variable），用于同步线程和触发唤醒。

使用标准库实现阻塞队列

下面是一个基于std::queue、std::mutex和std::condition_variable的简单阻塞队列实现：

立即学习“C++免费学习笔记（深入）”；

#include 
#include 
#include 
#include 

template
class BlockingQueue {
private:
    std::queue queue_;
    mutable std::mutex mtx_;
    std::condition_variable not_empty_;
    std::condition_variable not_full_;
    size_t capacity_;

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

    void put(T item) {
        std::unique_lock lock(mtx_);
        not_full_.wait(lock, [this] { return queue_.size() < capacity_; });
        queue_.push(std::move(item));
        not_empty_.notify_one();
    }

    T take() {
        std::unique_lock lock(mtx_);
        not_empty_.wait(lock, [this] { return !queue_.empty(); });
        T value = std::move(queue_.front());
        queue_.pop();
        not_full_.notify_one();
        return value;
    }

    bool empty() const {
        std::lock_guard lock(mtx_);
        return queue_.empty();
    }

    size_t size() const {
        std::lock_guard lock(mtx_);
        return queue_.size();
    }
};

说明：

跃问视频

阶跃星辰推出的AI视频生成工具

下载

• put() 在插入前等待队列不满，插入后通知等待的消费者
• take() 等待队列非空，取出后通知生产者
• 使用mutable修饰互斥锁，以便在const成员函数中加锁
• 采用std::unique_lock配合条件变量，支持等待时释放锁

线程安全与性能优化建议

虽然上述实现是线程安全的，但在高并发场景下仍有改进空间：

• 使用std::deque替代std::queue以支持高效首尾操作
• 添加超时版本的put/take，如bool try_put(T, timeout)，避免无限等待
• 对无界队列，只保留not_empty_条件变量即可
• 考虑使用无锁队列（如基于CAS操作）提升性能，但复杂度显著增加

实际使用示例

以下是一个简单的生产者-消费者测试：

int main() {
    BlockingQueue bq(5);

    std::thread producer([&bq]() {
        for (int i = 0; i < 10; ++i) {
            bq.put(i);
            std::cout << "Produced: " << i << "\n";
        }
    });

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

    producer.join();
    consumer.join();
    return 0;
}

这个例子展示了两个线程通过阻塞队列交换数据，无需额外同步逻辑。

基本上就这些。掌握阻塞队列的实现，有助于深入理解C++并发编程中的同步机制。不复杂但容易忽略细节，比如条件变量的谓词判断和notify的调用时机。