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

在云计算领域，构建多线程工作队列的方法有很多种。以下是一个简单的示例，使用 C++ 11 标准库中的线程和队列容器实现一个多线程生产者-消费者模式。

首先，我们需要包含必要的头文件和命名空间：

#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;
}

这个示例展示了如何使用 C++ 11 标准库中的线程和队列容器实现一个多线程生产者-消费者模式。当然，在实际应用中，您可能需要根据具体需求对其进行调整和优化。