Linux C++多线程编程中的线程安全队列实现

在 Linux 中，使用 C++ 实现线程安全队列需要考虑以下几点：

1. 使用互斥锁（mutex）保护共享资源，确保同一时间只有一个线程可以访问队列。
2. 使用条件变量（condition variable）来同步线程间的操作，例如当队列为空时，等待其他线程添加元素；当队列已满时，等待其他线程取出元素。
3. 使用原子操作（atomic operations）来避免不必要的锁竞争。

下面是一个简单的线程安全队列实现：

#include <iostream>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <thread>

template <typename T>
class ThreadSafeQueue {
public:
    // 入队操作
    void push(const T& item) {
        std::unique_lock<std::mutex> lock(mutex_);
        queue_.push(item);
        lock.unlock();
        cond_.notify_one();
    }

    // 出队操作
    bool pop(T& item) {
        std::unique_lock<std::mutex> lock(mutex_);
        while (queue_.empty()) {
            cond_.wait(lock);
        }
        item = queue_.front();
        queue_.pop();
        return true;
    }

    // 判断队列是否为空
    bool empty() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return queue_.empty();
    }

private:
    std::queue<T> queue_;
    mutable std::mutex mutex_;
    std::condition_variable cond_;
};

void producer(ThreadSafeQueue<int>& queue) {
    for (int i = 0; i < 10; ++i) {
        queue.push(i);
        std::cout << "Produced: "<< i << std::endl;
    }
}

void consumer(ThreadSafeQueue<int>& queue) {
    int item;
    for (int i = 0; i < 10; ++i) {
        while (!queue.pop(item)) {
            std::cout << "Consumed: Waiting for item" << std::endl;
        }
        std::cout << "Consumed: " << item << std::endl;
    }
}

int main() {
    ThreadSafeQueue<int> queue;
    std::thread producer_thread(producer, std::ref(queue));
    std::thread consumer_thread(consumer, std::ref(queue));

    producer_thread.join();
    consumer_thread.join();

    return 0;
}

这个实现中，我们使用了 std::queue 来存储数据，std::mutex 来保护队列，以及 std::condition_variable 来同步线程间的操作。生产者线程将元素添加到队列中，消费者线程从队列中取出元素。当队列为空时，消费者线程会等待生产者线程添加元素；当队列已满时，生产者线程会等待消费者线程取出元素。