线程安全队列通过互斥锁和条件变量实现，支持多线程环境下安全的入队、出队操作，空队列时阻塞等待。
在C++多线程编程中，线程安全的队列是常见的需求，尤其是在生产者-消费者模型中。要实现一个线程安全的队列，核心是保护共享数据不被多个线程同时访问导致竞争条件。通常使用互斥锁（std::mutex）配合条件变量（std::condition_variable）来实现高效、安全的操作。
基本设计思路
一个线程安全的队列需要满足以下几点：
- 多个线程可以安全地向队列中添加元素（入队）
- 多个线程可以安全地从队列中取出元素（出队）
- 当队列为空时，出队操作应阻塞等待，直到有新元素加入
- 使用RAII机制自动管理锁，避免死锁
为此，我们封装一个模板类，内部使用 std::queue 存储数据，用 std::mutex 保护访问，用 std::condition_variable 实现线程等待与唤醒。
线程安全队列的实现代码
#include <queue>
#include <mutex>
#include <condition_variable>
#include <thread>
template<typename T>
class ThreadSafeQueue {
private:
std::queue<T> data_queue;
mutable std::mutex mtx;
std::condition_variable cv;
public:
ThreadSafeQueue() = default;
void push(T value) {
std::lock_guard<std::mutex> lock(mtx);
data_queue.push(std::move(value));
cv.notify_one(); // 唤醒一个等待的消费者
}
bool try_pop(T& value) {
std::lock_guard<std::mutex> lock(mtx);
if (data_queue.empty()) {
return false;
}
value = std::move(data_queue.front());
data_queue.pop();
return true;
}
void wait_and_pop(T& value) {
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, [this] { return !data_queue.empty(); });
value = std::move(data_queue.front());
data_queue.pop();
}
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>
void producer(ThreadSafeQueue<int>& queue) {
for (int i = 0; i < 5; ++i) {
queue.push(i);
std::cout << "Produced: " << i << "\n";
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
void consumer(ThreadSafeQueue<int>& queue) {
for (int i = 0; i < 10; ++i) {
int value;
queue.wait_and_pop(value);
std::cout << "Consumed: " << value << "\n";
}
}
int main() {
ThreadSafeQueue<int> queue;
std::thread p1(producer, std::ref(queue));
std::thread p2(producer, std::ref(queue));
std::thread c1(consumer, std::ref(queue));
p1.join();
p2.join();
c1.join();
return 0;
}
关键点说明
push() 使用 std::lock_guard 自动加锁，插入后调用 notify_one() 唤醒一个等待线程。如果多个消费者在等待，只会唤醒一个，避免惊群效应。
wait_and_pop() 使用 std::unique_lock 配合 cv.wait()，只有当队列非空时才继续执行，否则阻塞。这比忙等更高效。
try_pop() 提供非阻塞版本，适合不需要等待的场景。
所有公共方法都对内部队列加锁，确保任意时刻只有一个线程能修改或读取数据。
基本上就这些。这个实现简单、安全，适用于大多数多线程场景。如果需要更高性能，可考虑无锁队列（lock-free queue），但复杂度会显著上升。当前基于锁的方案在多数应用中已足够高效。
