c++版线程池和任务池示例

下面是一个简单的C++线程池和任务池的示例。这个示例中，我们将使用C++11标准中的线程、互斥锁、条件变量以及`std::function`和`std::queue`来实现。

### 线程池类

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

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

    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop = false;

    void workerThread() {
        while (true) {
            std::function<void()> task;

            {
                std::unique_lock<std::mutex> lock(queue_mutex);
                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();
        }
    }

public:
    ThreadPool(size_t threads) {
        for (size_t i = 0; i < threads; ++i) {
            workers.emplace_back(&ThreadPool::workerThread, this);
        }
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();

        for (std::thread &worker: workers) {
            worker.join();
        }
    }

    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type> {
        using return_type = typename std::result_of<F(Args...)>::type;

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

        std::future<return_type> res = task->get_future();
        {
            std::unique_lock<std::mutex> lock(queue_mutex);

            // The lambda captures 'shared_ptr' so it will keep the task alive
            tasks.emplace([task](){ (*task)(); });
        }
        condition.notify_one();
        return res;
    }
};

int main() {
    ThreadPool pool(4);

    // 示例：添加任务
    auto result = pool.enqueue([](int answer){
        return answer * answer;
    }, 42);

    std::cout << "The answer is " << result.get() << std::endl;

    return 0;
}

### 说明

1. **线程池**：使用`std::vector`来存储工作线程。

2. **任务队列**：使用`std::queue>`来存储待执行的任务。

3. **同步机制**：使用`std::mutex`和`std::condition_variable`来控制对任务队列的访问和等待新任务。

4. **停止机制**：当设置`stop`标志并且任务队列为空时，工作线程将退出。

5. **任务提交**：`enqueue`方法允许提交任意可调用对象（函数、lambda表达式等），并返回一个`std::future`对象，以便获取任务的返回值（如果任务有返回值的话）。

这个示例展示了如何使用C++11的并发工具来创建一个简单的线程池和任务池。注意，为了简化，我们没有处理所有可能的错误情况（如任务队列的异常安全等）。