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 來同步線程間的操作。生產者線程將元素添加到隊列中，消費者線程從隊列中取出元素。當隊列為空時，消費者線程會等待生產者線程添加元素；當隊列已滿時，生產者線程會等待消費者線程取出元素。