c++如何实现一个线程安全的队列_c++线程安全队列设计与实现方法-C++-PHP中文网

c++如何实现一个线程安全的队列_c++线程安全队列设计与实现方法

穿越時空

发布： 2025-10-26 18:44:01

原创

171人浏览过

使用互斥锁和条件变量实现线程安全队列，通过std::mutex保护共享数据、std::condition_variable支持阻塞等待，确保多线程环境下队列操作的安全性与效率。

c++如何实现一个线程安全的队列_c++线程安全队列设计与实现方法

在多线程编程中，多个线程可能同时访问和修改共享数据，因此需要保证数据的一致性和安全性。队列作为一种常见的数据结构，在任务调度、生产者-消费者模型等场景中广泛使用。实现一个线程安全的队列是C++并发编程中的基础需求。下面介绍一种基于标准库组件的线程安全队列设计与实现方法。

使用 std::queue 与 std::mutex 实现基本线程安全队列

最直接的方式是封装一个普通队列，并用互斥锁保护所有操作，确保同一时间只有一个线程能访问内部数据。

关键点：

使用 std::queue 作为底层容器
使用 std::mutex 保护 push 和 pop 操作
使用 std::lock_guard 管理锁的生命周期，防止死锁

#include <queue>
#include <mutex>

template<typename T>
class ThreadSafeQueue {
private:
    std::queue<T> data_queue;
    mutable std::mutex mut;

public:
    ThreadSafeQueue() {}

    void push(T item) {
        std::lock_guard<std::mutex> lock(mut);
        data_queue.push(std::move(item));
    }

    bool try_pop(T& value) {
        std::lock_guard<std::mutex> lock(mut);
        if (data_queue.empty()) {
            return false;
        }
        value = std::move(data_queue.front());
        data_queue.pop();
        return true;
    }

    std::shared_ptr<T> try_pop() {
        std::lock_guard<std::mutex> lock(mut);
        if (data_queue.empty()) {
            return nullptr;
        }
        auto result = std::make_shared<T>(std::move(data_queue.front()));
        data_queue.pop();
        return result;
    }

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

登录后复制

支持等待的阻塞队列（Blocking Queue）

在某些场景下，消费者线程希望在队列为空时自动等待，直到有新元素被加入。这时可以引入条件变量来实现阻塞式操作。

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

创客贴设计

创客贴设计，一款智能在线设计工具，设计不求人，AI助你零基础完成专业设计！

查看详情

改进点：

添加 std::condition_variable 用于通知等待线程
提供阻塞版本的 pop 接口

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

template<typename T>
class BlockingQueue {
private:
    std::queue<T> data_queue;
    mutable std::mutex mut;
    std::condition_variable cond;

public:
    void push(T item) {
        std::lock_guard<std::mutex> lock(mut);
        data_queue.push(std::move(item));
        cond.notify_one(); // 唤醒一个等待线程
    }

    void wait_and_pop(T& value) {
        std::unique_lock<std::mutex> lock(mut);
        cond.wait(lock, [this]{ return !data_queue.empty(); });
        value = std::move(data_queue.front());
        data_queue.pop();
    }

    std::shared_ptr<T> wait_and_pop() {
        std::unique_lock<std::mutex> lock(mut);
        cond.wait(lock, [this]{ return !data_queue.empty(); });
        auto result = std::make_shared<T>(std::move(data_queue.front()));
        data_queue.pop();
        return result;
    }

    bool try_pop(T& value) {
        std::lock_guard<std::mutex> lock(mut);
        if (data_queue.empty())
            return false;
        value = std::move(data_queue.front());
        data_queue.pop();
        return true;
    }

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

登录后复制