用C++构建多线程工作队列(使用者/生产者)

#include<iostream>
#include<queue>
#include<thread>
#include <mutex>
#include<condition_variable>
#include<vector>
#include<chrono>
#include<atomic>

class WorkQueue {
public:
    WorkQueue() : stop(false) {}

    void push_task(int task) {
        std::unique_lock<std::mutex> lock(mutex);
        tasks.push(task);
        cv.notify_one();
    }

    bool pop_task(int& task) {
        std::unique_lock<std::mutex> lock(mutex);
        cv.wait(lock, [this] { return !tasks.empty() || stop; });
        if (tasks.empty()) return false;
        task = tasks.front();
        tasks.pop();
        return true;
    }

    void stop_queue() {
        stop.store(true);
        cv.notify_all();
    }

private:
    std::queue<int> tasks;
    std::mutex mutex;
    std::condition_variable cv;
    std::atomic<bool> stop;
};

void producer(WorkQueue& queue, int num_tasks) {
    for (int i = 0; i < num_tasks; ++i) {
        queue.push_task(i);
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    queue.stop_queue();
}

void consumer(WorkQueue& queue) {
    int task;
    while (queue.pop_task(task)) {
        std::cout << "Consumer processing task: "<< task<< std::endl;
    }
}

int main() {
    WorkQueue queue;
    int num_tasks = 10;

    std::thread producer_thread(producer, std::ref(queue), num_tasks);
    std::thread consumer_thread(consumer, std::ref(queue));

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

    return 0;
}