C++如何实现一个阻塞队列_C++多线程编程与阻塞队列实现

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

template<typename T>
class BlockingQueue {
private:
    std::queue<T> data_queue;
    mutable std::mutex mtx;
    std::condition_variable not_empty;
    std::condition_variable not_full;
    size_t max_size;

public:
    explicit BlockingQueue(size_t max = 1000) : max_size(max) {}

    void put(const T& value) {
        std::unique_lock<std::mutex> lock(mtx);
        not_full.wait(lock, [this] { return data_queue.size() < max_size; });
        data_queue.push(value);
        not_empty.notify_one();
    }

    void take(T& value) {
        std::unique_lock<std::mutex> lock(mtx);
        not_empty.wait(lock, [this] { return !data_queue.empty(); });
        value = data_queue.front();
        data_queue.pop();
        not_full.notify_one();
    }

    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>

void producer(BlockingQueue<int>& queue) {
    for (int i = 0; i < 5; ++i) {
        queue.put(i);
        std::cout << "Produced: " << i << "\n";
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
}

void consumer(BlockingQueue<int>& queue) {
    for (int i = 0; i < 5; ++i) {
        int value;
        queue.take(value);
        std::cout << "Consumed: " << value << "\n";
    }
}

int main() {
    BlockingQueue<int> queue(3); // 容量为3的队列

    std::thread p(producer, std::ref(queue));
    std::thread c(consumer, std::ref(queue));

    p.join();
    c.join();

    return 0;
}