C++ 线程池

//C++线程池是一种多线程技术，它可以在程序运行时创建一组线程，

//并将任务分配给这些线程来执行。
//线程池可以提高程序的并发性和性能，特别是在处理大量任务时。
//以下是C++线程池的常用方法和一个简单的例子：

//1. 创建线程池

//可以使用C++标准库中的std::thread和std::vector来创建线程池。
//首先，定义一个线程池类，其中包含一个std::vector来存储线程对象和一个std::queue来存储任务

//对象。
//然后，在构造函数中创建线程对象，并将它们存储在std::vector中。

//c++
class ThreadPool 
{
public:
    ThreadPool(int numThreads) 
{
        for (int i = 0; i < numThreads; ++i) 
{
            threads.emplace_back([this]
 {
                while (true) {
                    std::function task;
                    {
                        std::unique_lock lock(mutex);
                        condition.wait(lock, [this] { return stop || !tasks.empty(); });
                        if (stop && tasks.empty())
           {
                            return;
                        }
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    task();
                }
            });
        }
    }
    // ...
private:
    std::vector threads;
    std::queue> tasks;
    std::mutex mutex;
    std::condition_variable condition;
    bool stop = false;
};
//

//2. 添加任务

//可以使用std::function和std::bind来创建任务对象，并将它们存储在std::queue中。
//然后，使用std::unique_lock和std::condition_variable来通知线程池中的线程有新的任务可用。

//c++
class ThreadPool 
{
public:
    template
    auto enqueue(F&& f, Args&&... args) -> std::future::type> 
   {
        using return_type = typename std::result_of::type;
        auto task = std::make_shared>(std::bind(std::forward(f), std::forward(args)...));
        std::future result = task->get_future();
        {
            std::unique_lock lock(mutex);
            if (stop) {
                throw std::runtime_error("enqueue on stopped ThreadPool");
            }
            tasks.emplace([task] { (*task)(); });
        }
        condition.notify_one();
        return result;
    }
    // ...
};
//

//3. 停止线程池

可以使用std::unique_lock和std::condition_variable来通知线程池中的线程停止运行，并等待它们完成当前任务。

//c++
class ThreadPool {
public:
    ~ThreadPool() {
        {
            std::unique_lock lock(mutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread& thread : threads) {
            thread.join();
        }
    }
    // ...
};
//

//4.下面是一个简单的例子，演示如何使用C++线程池来计算斐波那契数列：

//c++
#include
#include
#include "ThreadPool.h"

int fib(int n)

{
    if (n < 2)

   {
        return n;
    }
    return fib(n - 1) + fib(n - 2);
}

int main() {
    ThreadPool pool(4);
    std::vector> results;
    for (int i = 0; i < 10; ++i)

   {
        results.emplace_back(pool.enqueue(fib, i));
    }
    for (auto& result : results)

   {
        std::cout << result.get() << " ";
    }
    std::cout << std::endl;
    return 0;
}
//

//在这个例子中，我们创建了一个ThreadPool对象，它包含4个线程。
//然后，我们使用enqueue方法将10个斐波那契数列的计算任务添加到线程池中。
//最后，我们使用std::future来获取每个任务的结果，并将它们打印到控制台上。