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

该文实现了基于C++标准库的线程安全阻塞队列模板类BlockingQueue，支持容量限制、阻塞入队/出队及超时尝试出队；配套生产者生成随机数、消费者取数处理，并通过多线程协同演示完整生产者-消费者模型。

（以下为纯 C++ 多线程阻塞队列 + 生产者消费者模型实现，基于标准库 <queue></queue>、<mutex></mutex>、<condition_variable></condition_variable> 和 <thread></thread>，无第三方依赖，可直接编译运行）

核心思路：用互斥锁保护共享队列，用条件变量让空队列时消费者等待、满队列时生产者等待。C++ 标准库的 std::condition_variable 天然支持“等待某个条件成立”，配合 wait() 和 notify_one()/notify_all() 即可实现线程安全的阻塞行为。

1. 线程安全的阻塞队列模板类

支持任意类型 T，可设容量上限（可选），内部自动处理 wait/notify 逻辑：

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

template<typename T>
class BlockingQueue {
private:
    std::queue<T> q;
    mutable std::mutex mtx;
    std::condition_variable not_empty;   // 消费者等待：队列非空
    std::condition_variable not_full;    // 生产者等待：队列未满（若限容）
    size_t max_size = 0;                 // 0 表示无容量限制

public:
    explicit BlockingQueue(size_t capacity = 0) : max_size(capacity) {}

    // 入队（阻塞直到有空间）
    void push(const T& item) {
        std::unique_lock<std::mutex> lock(mtx);
        if (max_size > 0) {
            not_full.wait(lock, [this] { return q.size() < max_size; });
        }
        q.push(item);
        not_empty.notify_one(); // 唤醒一个等待消费的线程
    }

    // 出队（阻塞直到有数据）
    T pop() {
        std::unique_lock<std::mutex> lock(mtx);
        not_empty.wait(lock, [this] { return !q.empty(); });
        T front = std::move(q.front());
        q.pop();
        if (max_size > 0) {
            not_full.notify_one(); // 可能腾出空间，唤醒一个等待生产的线程
        }
        return front;
    }

    // 尝试出队（带超时，返回 false 表示超时或为空）
    bool try_pop(T& item, int timeout_ms = 0) {
        std::unique_lock<std::mutex> lock(mtx);
        if (timeout_ms == 0) {
            not_empty.wait(lock, [this] { return !q.empty(); });
        } else {
            auto dur = std::chrono::milliseconds(timeout_ms);
            if (!not_empty.wait_for(lock, dur, [this] { return !q.empty(); })) {
                return false;
            }
        }
        item = std::move(q.front());
        q.pop();
        if (max_size > 0) not_full.notify_one();
        return true;
    }

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

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

2. 生产者与消费者函数（分离职责）

每个生产者/消费者都是独立函数，通过引用使用同一个队列，适合传给 std::thread：

Prisma

Prisma是一款照片编辑工具，用户可以轻松地将照片转换成数字艺术。

92 查看详情 Prisma

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

#include <iostream>
#include <thread>
#include <vector>
#include <random>

// 生产者：生成随机数并入队
void producer(BlockingQueue<int>& bq, int id, int count) {
    std::mt19937 gen(id);
    std::uniform_int_distribution<int> dist(1, 100);
    for (int i = 0; i < count; ++i) {
        int val = dist(gen);
        bq.push(val);
        std::cout << "[P" << id << "] pushed " << val << "\n";
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

// 消费者：取数、打印、简单处理
void consumer(BlockingQueue<int>& bq, int id, int total) {
    for (int i = 0; i < total; ++i) {
        int val = bq.pop(); // 阻塞等待
        std::cout << "  [C" << id << "] popped " << val << "\n";
        std::this_thread::sleep_for(std::chrono::milliseconds(150));
    }
}

3. 主函数：启动多线程并协同运行

注意：需确保生产总数 ≥ 消费总数，否则消费者会永久阻塞（实际项目中建议加退出信号或使用 `try_pop` + 超时 + 中断机制）：

int main() {
    BlockingQueue<int> bq(10); // 容量为 10 的有界队列

    const int num_producers = 2;
    const int num_consumers = 3;
    const int items_per_producer = 5;

    std::vector<std::thread> threads;

    // 启动生产者
    for (int i = 0; i < num_producers; ++i) {
        threads.emplace_back(producer, std::ref(bq), i, items_per_producer);
    }

    // 启动消费者（总消费数 = 总生产数）
    int total_items = num_producers * items_per_producer;
    for (int i = 0; i < num_consumers; ++i) {
        int each = total_items / num_consumers;
        int rest = (i == 0) ? total_items % num_consumers : 0;
        threads.emplace_back(consumer, std::ref(bq), i, each + rest);
    }

    // 等待所有线程结束
    for (auto& t : threads) {
        if (t.joinable()) t.join();
    }

    std::cout << "All done.\n";
    return 0;
}

4. 关键细节提醒

始终用 std::unique_lock 配合 wait：它允许在等待期间临时释放锁，并在唤醒后自动重新加锁；普通 lock_guard 不支持
条件检查必须用 lambda（谓词重载）：避免虚假唤醒（spurious wakeup），不要只用 wait(lock) 后手动判断
notify_one() 通常够用：除非多个线程等待同一条件且需全部响应（如广播终止信号），否则用 notify_one() 更高效
移动语义优化：pop 中用 std::move(q.front()) 避免不必要的拷贝（尤其对大对象）
异常安全：所有 RAII 锁（unique_lock / lock_guard）保证异常时自动解锁

基本上就这些。不复杂但容易忽略条件变量的谓词写法和锁的搭配——写对了，就是教科书级的线程安全阻塞队列。

以上就是c++++怎么实现一个阻塞队列_c++生产者消费者模型实现【多线程】的详细内容，更多请关注其它相关文章！

# 并在 # 广州网站建设天维 # 烟草建设网站 # 商南短视频seo地址 # 顺德家政网站建设 # 网站推广渠道运营方案 # 武侯区网站推广建设优化 # 庆阳网站建设及推广 # 网站下线推广 # 零售怎么抖音推广优化营销 # 成安优化seo # 中文网 # 相关文章 # ai # 多个 # 边缘 # 都是 # 游戏开发 # 如何实现 # 随机数 # 多线程 # 标准库 # stream # ios # c++

相关栏目：【 Google疑问12 】【 Facebook疑问10 】【优化推广96088 】【技术知识133117 】【 IDC资讯59369 】【网络运营7196 】【 IT资讯61894 】

2025-12-20

SQL多表关联如何理解_核心原理解析助你掌握关键方法【教程】 SQL多表连接如何理解_JOIN关联关系详细步骤解析【指导】 SQL多表连接结果异常怎么办_JOIN条件排查方法解析【指导】 SQL索引下推是什么_ICP机制性能提升原理【教程】 SQL跨表统计怎么写_重要技巧总结提升查询效率【技巧】 SQL注入如何防护_完整逻辑拆解助力系统化掌握【技巧】 SQL上传文件信息建模方法_SQL存储文件元数据方案 SQL多语种存储方案设计_SQL字符集选择策略 SQL字符串处理如何编写_重要技巧总结提升查询效率【教学】 SQL去重查询怎么实现_优化思路讲解帮助高效处理数据【技巧】 SQL统计复购用户怎么做_多次行为分析SQL思路【教程】 SQL字符串处理如何编写_优化思路讲解帮助高效处理数据【教程】 SQL动态字段解析技巧_SQL解析JSON多层字段 SQL线上慢SQL如何治理_规范与工具实践总结【技巧】 SQL表结构如何演进_兼容老数据设计思路【教程】 SQL排序规则如何设置_ORDERBY排序原理与性能说明【指导】 SQL去重查询怎么实现_真实案例解析强化复杂查询思维【教学】 SQL按字段范围分批处理_SQL避免长时间锁表 SQL统计不同字段组合数量_多列聚合查询技巧【技巧】 SQL多字段去重怎么处理_GROUPBY去重思路说明【教学】

了解您产品搜索量及市场趋势，制定营销计划

同行竞争及网站分析保障您的广告效果

点击免费数据支持

提交您的需求，1小时内享受我们的专业解答。

运城市盐湖区信雨科技有限公司

运城市盐湖区信雨科技有限公司是一家深耕海外推广领域十年的专业服务商，作为谷歌推广与Facebook广告全球合作伙伴，聚焦外贸企业出海痛点，以数字化营销为核心，提供一站式海外营销解决方案。公司凭借十年行业沉淀与平台官方资源加持，打破传统外贸获客壁垒，助力企业高效开拓全球市场，成为中小企业出海的可靠合作伙伴。