答案：通过结合std::queue、std::mutex和std::condition_variable实现线程安全队列，支持阻塞式入队和出队操作。使用互斥锁保护共享数据，条件变量等待非空队列，notify_one唤醒等待线程，提供empty和size方法查询状态，支持生产者-消费者模型。
在C++中实现一个线程安全的队列，关键在于保护共享数据不被多个线程同时访问导致竞争条件。最常用的方法是结合 std::queue、std::mutex 和 std::condition_variable 来实现阻塞式线程安全队列。下面是一个实用且高效的实现方式。
基本设计思路
线程安全队列需要满足以下几点：
- 多个线程可以安全地入队（push）和出队（pop）
- 当队列为空时，pop操作可以阻塞等待新元素
- 使用互斥锁保护队列数据结构
- 使用条件变量通知等待的线程
线程安全队列实现代码
#include <queue>
#include <mutex>
#include <condition_variable>
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(); // 唤醒一个等待的pop线程
}
void 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();
}
std::shared_ptr<T> pop() {
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, [this]{ return !data_queue.empty(); });
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(mtx);
return data_queue.empty();
}
size_t size() const {
std::lock_guard<std::mutex> lock(mtx);
return data_queue.size();
}
};
使用示例
下面是一个生产者-消费者模型的简单使用场景：
#include <iostream>
#include <thread>
void producer(ThreadSafeQueue<int>& queue) {
for (int i = 0; i < 5; ++i) {
queue.push(i);
std::cout << "Produced: " << i << "\n";
}
}
void consumer(ThreadSafeQueue<int>& queue) {
for (int i = 0; i < 5; ++i) {
int value;
queue.pop(value);
std::cout << "Consumed: " << value << "\n";
}
}
int main() {
ThreadSafeQueue<int> queue;
std::thread p(producer, std::ref(queue));
std::thread c(consumer, std::ref(queue));
p.join();
c.join();
return 0;
}
关键点说明
push() 中使用 notify_one() 及时唤醒等待的消费者线程。
pop(T&) 和 pop() 返回 shared_ptr 是两种常见接口风格，后者避免了对象复制且更安全。
cv.wait() 使用 lambda 判断条件，防止虚假唤醒。
所有公共方法都通过锁保护内部队列，确保线程安全。
