C++线程池

线程池实现重点：

1.标题核心组件：

• 工作线程集合：std::vector< std::thread >
• 任务队列：std::queue<std::function<void()>>
• 同步机制：std::mutex和std::condition_variable
• 停止标志：std::atomic

2.关键功能：

• 构造函数：创建指定数量的工作线程
• enqueue方法：提交任务并返回std::future
• 析构函数：停止所有线程并释放资源

3.异步处理：

• 使用std::packaged_task和std::future提供异步结果获取
• 模板化任务提交接口，支持任意函数和参数
• 支持返回值通过future获取

4.线程池使用方法：

• 创建线程池：ThreadPool pool(线程数量);
• 提交任务：auto future = pool.enqueue(函数, 参数…);
• 获取结果：auto result = future.get();

#include <iostream>
#include <vector>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <future>
#include <memory>
#include <atomic>

class ThreadPool {
public:
    // 构造函数，创建指定数量的工作线程
    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(queueMutex);
                        condition.wait(lock, [this] {
                            return stop || !tasks.empty();
                        });

                        if (stop && tasks.empty()) {
                            return;  // 如果线程池停止且任务队列为空，则退出线程
                        }

                        task = std::move(tasks.front());
                        tasks.pop();
                    }

                    task();  // 执行任务
                }
            });
        }
    }

    // 析构函数，停止所有工作线程
    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            stop = true;
        }

        condition.notify_all();

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

    // 禁止拷贝构造和赋值操作
    ThreadPool(const ThreadPool&) = delete;
    ThreadPool& operator=(const ThreadPool&) = delete;

    // 提交任务到线程池并返回未来结果
    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> result = task->get_future();

        {
            std::unique_lock<std::mutex> lock(queueMutex);

            // 如果线程池已停止，抛出异常
            if (stop) {
                throw std::runtime_error("enqueue on stopped ThreadPool");
            }

            // 将任务添加到队列
            tasks.emplace([task]() { (*task)(); });
        }

        condition.notify_one();  // 通知一个等待中的线程
        return result;
    }

    // 获取当前线程池大小
    size_t size() const {
        return workers.size();
    }

    // 获取当前队列中的任务数量
    size_t queueSize() const {
        std::unique_lock<std::mutex> lock(queueMutex);
        return tasks.size();
    }

private:
    std::vector<std::thread> workers;                   // 工作线程集合
    std::queue<std::function<void()>> tasks;            // 任务队列

    mutable std::mutex queueMutex;                      // 任务队列互斥锁
    std::condition_variable condition;                  // 条件变量，用于线程同步
    std::atomic<bool> stop;                             // 线程池停止标志
};

// 使用示例
int main() {
    // 创建一个具有4个线程的线程池
    ThreadPool pool(4);

    // 一些将被添加到线程池的示例函数
    auto task1 = [](int ms, int id) {
        std::cout << "Task " << id << " starting in thread "
                  << std::this_thread::get_id() << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(ms));
        std::cout << "Task " << id << " finished" << std::endl;
        return id * 2;
    };

    // 用于存储异步任务的future
    std::vector<std::future<int>> results;

    // 提交一些任务
    for (int i = 0; i < 8; ++i) {
        results.emplace_back(
                pool.enqueue(task1, i * 100 + 100, i)
        );
    }

    // 获取结果
    for (auto& result : results) {
        std::cout << "Result: " << result.get() << std::endl;
    }

    std::cout << "All tasks completed." << std::endl;

    return 0;
}