写出一个c++线程池代码

以下是一个简单的 C++ 线程池代码，可以用于任务的并行处理：

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

class ThreadPool {
public:
    ThreadPool(size_t threads) : stop(false) {
        for (size_t i = 0; i < threads; ++i)
            workers.emplace_back(
                [this] {
                    for (;;) {
                        std::function<void()> task;
                        {
                            std::unique_lock<std::mutex> lock(this->queue_mutex);
                            this->condition.wait(lock, [this] { return this->stop || !this->tasks.empty(); });
                            if (this->stop && this->tasks.empty())
                                return;
                            task = std::move(this->tasks.front());
                            this->tasks.pop();
                        }
                        task();
                    }
                }
            );
    }

    template<class F>
    void enqueue(F&& f) {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            tasks.emplace(std::forward<F>(f));
        }
        condition.notify_one();
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread &worker : workers)
            worker.join();
    }

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;

    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};

在这个代码中，我们定义了一个 ThreadPool 类，它包含一个工作线程队列和一个任务队列，以及一个互斥锁和一个条件变量来保证线程安全。构造函数接受一个参数，表示要创建的工作线程的数量，然后创建相应数量的线程，并将它们加入工作线程队列中。enqueue() 方法用于将任务添加到任务队列中，同时通知一个工作线程来处理它。最后，在析构函数中，我们设置 stop 标志以通知所有线程退出，并等待所有线程完成工作。