C++线程池的简单实现方法

C++线程池是一种常用的并发编程技术，它允许我们创建一组固定数量的线程并维护它们，以便在需要时可以立即使用它们来执行任务。下面是一个C++线程池的简单实现方法：

1. 定义任务队列

首先，我们需要定义一个任务队列，用于存储等待执行的任务。任务队列可以是一个简单的std::queue对象，用于存储任务函数。

std::queue<std::function<void()>> taskQueue;

这里使用了std::function对象来存储要执行的任务函数，以便可以存储任意类型的函数。

1. 定义线程池类

接下来，我们需要定义一个线程池类，用于创建和管理线程池。线程池类应该包含一个std::vector对象，用于存储所有的线程对象。线程池初始化时应该创建并启动所有的线程，每个线程应该不断地从任务队列中获取任务并执行。

class ThreadPool {
public:
    explicit ThreadPool(int numThreads) : stop(false) {
        for (int i = 0; i < numThreads; ++i) {
            workers.emplace_back(
                [this] {
                    while (true) {
                        std::function<void()> task;
                        {
                            std::unique_lock<std::mutex> lock(queueMutex);
                            condition.wait(lock, [this] { return stop || !taskQueue.empty(); });
                            if (stop && taskQueue.empty())
                                return;
                            task = std::move(taskQueue.front());
                            taskQueue.pop();
                        }
                        task();
                    }
                }
            );
        }
    }

    template<class F>
    void enqueue(F f) {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            taskQueue.emplace(f);
        }
        condition.notify_one();
    }

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

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

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

这里的ThreadPool类包含了enqueue()方法，用于向任务队列中添加新的任务函数。当一个新的任务函数添加到队列中后，我们要通知一个线程来执行这个任务。

1. 创建线程池并执行任务

下面是一个简单的示例，展示如何创建一个ThreadPool对象，并在线程池中执行一些任务：

int main() {
    ThreadPool pool(4);
    for (int i = 0; i < 8; ++i) {
        pool.enqueue([] {
            std::cout << "Hello, world!\n";
        });
    }
    return 0;
}

这个示例中，首先创建一个ThreadPool对象，其将由4个线程处理任务。然后我们将8个任务添加到ThreadPool对象中，并在每个任务中打印“Hello, world!”。

1. 示例2：用线程池计算斐波那契数列

下面是另一个示例，演示如何将线程池用于计算斐波那契数列。我们将使用递归的方式计算斐波那契数列，然后将计算过程分解为多个任务，将这些任务提交给线程池进行计算。

#include <iostream>
#include <chrono>
#include "ThreadPool.h"

int fib(int n) {
    if (n <= 1) {
        return n;
    } else {
        return fib(n - 1) + fib(n - 2);
    }
}

int main() {
    const int n = 40;
    ThreadPool pool(4);
    auto start = std::chrono::high_resolution_clock::now();
    auto fibFuture = pool.enqueue([&] { return fib(n); });
    auto result = fibFuture.get();
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double, std::milli> duration = end - start;
    std::cout << "Fibonacci(" << n << ") = " << result << "\n";
    std::cout << "Calculated in " << duration.count() << " milliseconds\n";
    return 0;
}

这次我们创建了ThreadPool对象，使用4个线程进行计算任务。在主函数中，我们通过递归方式计算斐波那契数列，然后将该计算分解为一个任务提交给线程池进行计算。最后，我们通过std::future对象获取结果，并打印出计算时间和结果。