C++怎么实现一个线程池_C++高性能并发模型与ThreadPool设计

#include <iostream>
#include <vector>
#include <queue>
#include <thread>
#include <functional>
#include <future>
#include <mutex>
#include <condition_variable>
<p>class ThreadPool {
public:
explicit ThreadPool(size_t numThreads) : stop(false) {
for (size_t i = 0; i < numThreads; ++i) {
workers.emplace_back([this] {
while (true) {
std::function<void()> task;
{
std::unique_lock<std::mutex> lock(tasksMutex);
cv.wait(lock, [this] { return stop || !tasks.empty(); });
if (stop && tasks.empty()) return;
task = std::move(tasks.front());
tasks.pop();
}
task();
}
});
}
}</p><pre class='brush:php;toolbar:false;'>template<typename F, typename... Args>
auto enqueue(F&& f, Args&&... args) 
    -> std::future<decltype(f(args...))> {
    using ReturnType = decltype(f(args...));

    auto task = std::make_shared<std::packaged_task<ReturnType()>>(
        std::bind(std::forward<F>(f), std::forward<Args>(args)...)
    );

    std::future<ReturnType> result = task->get_future();
    {
        std::lock_guard<std::mutex> lock(tasksMutex);
        if (stop) throw std::runtime_error("enqueue on stopped ThreadPool");
        tasks.emplace([task]() { (*task)(); });
    }
    cv.notify_one();
    return result;
}

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

std::mutex tasksMutex;
std::condition_variable cv;
bool stop;

int main() {
    ThreadPool pool(4); // 创建4个线程的线程池
<pre class='brush:php;toolbar:false;'>std::vector<std::future<int>> results;

for (int i = 0; i < 8; ++i) {
    results.emplace_back(
        pool.enqueue([i] {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            return i * i;
        })
    );
}

for (auto& result : results) {
    std::cout << result.get() << ' ';
}
std::cout << std::endl;

return 0;