c++怎么编写一个线程池_c++多线程任务调度与并发执行框架实现

新闻中心 NEWS CENTER

您当前位置：首页 > 新闻中心 > 网络学院

c++怎么编写一个线程池_c++多线程任务调度与并发执行框架实现

2025-11-09

浏览次数：次

返回列表

线程池通过复用线程和任务队列提升并发效率，核心组件包括任务队列、线程集合、同步机制及支持返回值的future/promise设计，适用于短小频繁任务，建议合理设置线程数并优化队列性能。

c++怎么编写一个线程池_c++多线程任务调度与并发执行框架实现

线程池的基本结构设计

在C++中实现一个线程池，核心是管理一组可复用的工作线程，并通过任务队列来调度执行。线程池避免了频繁创建和销毁线程的开销，提升并发效率。

基本组件包括：

任务队列：存放待处理的任务，通常使用std::queue配合互斥锁保护
线程集合：一组长期运行的线程，循环从任务队列中取任务执行
同步机制：使用std::mutex和std::condition_variable实现线程安全与唤醒等待
任务类型：使用std::function<void></void>封装任意可调用对象

任务提交与线程工作逻辑

主线程通过接口提交任务，工作线程阻塞等待新任务。当有任务加入时，通知至少一个线程进行处理。

关键代码结构如下：

class ThreadPool {
private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex task_mutex;
    std::condition_variable cv;
    bool stop = false;

public:
    explicit ThreadPool(size_t num_threads) {
        for (size_t i = 0; i < num_threads; ++i) {
            workers.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(task_mutex);
                        cv.wait(lock, [this] { return stop || !tasks.empty(); });
                        if (stop && tasks.empty()) return;
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    task(); // 执行任务
                }
            });
        }
    }

    template<class F>
    void enqueue(F&& f) {
        {
            std::lock_guard<std::mutex> lock(task_mutex);
            tasks.emplace(std::forward<F>(f));
        }
        cv.notify_one();
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(task_mutex);
            stop = true;
        }
        cv.notify_all();
        for (auto& w : workers)
            w.join();
    }
};

支持返回值的任务（future/promise）

为了让提交的任务能获取结果，可以结合std::packaged_task和std::future。

修改enqueue模板函数：

易标AI

告别低效手工，迎接AI标书新时代！3分钟智能生成，行业唯一具备查重功能，自动避雷废标项

135 查看详情易标AI

template<class F>
auto submit(F&& f) -> std::future<decltype(f())> {
    using ReturnType = decltype(f());
    auto task = std::make_shared<std::packaged_task<ReturnType()>>(std::forward<F>(f));
    std::future<ReturnType> result = task->get_future();
    {
        std::lock_guard<std::mutex> lock(task_mutex);
        tasks.emplace([task]() { (*task)(); });
    }
    cv.notify_one();
    return result;
}

这样就可以异步获取执行结果：

auto future1 = pool.submit([]() { return 42; });
auto future2 = pool.submit([]() { std::this_thread::sleep_for(1s); return "done"; });

int val = future1.get();        // 阻塞直到完成
std::string msg = future2.get(); // 获取字符串结果