c++中怎么实现一个线程池_C++高性能线程池设计与实现-C++-PHP中文网

c++中怎么实现一个线程池_C++高性能线程池设计与实现

裘德小鎮的故事

发布： 2025-09-27 19:16:02

原创

747人浏览过

答案：C++线程池通过复用固定数量的工作线程、任务队列和条件变量实现高效任务调度，支持异步提交与返回值获取，结合RAII管理生命周期，并可通过无锁队列、任务窃取等优化提升性能。

c++中怎么实现一个线程池_c++高性能线程池设计与实现

在C++中实现一个高性能线程池，核心目标是复用线程、减少频繁创建销毁的开销，并高效调度任务。下面是一个简洁、实用且线程安全的线程池设计与实现方式。

线程池基本结构

一个典型的线程池包含以下几个部分：

工作线程集合：固定数量的线程在后台等待任务。
任务队列：存放待执行的函数对象（std::function<void()>）。
同步机制：使用互斥锁（std::mutex）和条件变量（std::condition_variable）协调线程与任务的交互。
控制开关：用于安全关闭线程池。

任务提交与执行

用户通过enqueue方法提交任务，线程池将任务推入队列，唤醒一个工作线程执行。

使用std::packaged_task结合std::future，可以方便地获取任务返回值。

立即学习“C++免费学习笔记（深入）”；

设计师AI工具箱

最懂设计师的效率提升平台，实现高效设计出图和智能改图，室内设计，毛坯渲染，旧房改造，软装设计

124

查看详情

示例代码如下：

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

class ThreadPool {
public:
    explicit ThreadPool(size_t num_threads)
        : stop_(false) {
        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(queue_mutex_);
                        condition_.wait(lock, [this] { return stop_ || !tasks_.empty(); });
                        if (stop_ && tasks_.empty()) return;
                        task = std::move(tasks_.front());
                        tasks_.pop();
                    }
                    task();
                }
            });
        }
    }

    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::lock_guard<std::mutex> lock(queue_mutex_);

            if (stop_) {
                throw std::runtime_error("enqueue on stopped ThreadPool");
            }

            tasks_.emplace([task]() { (*task)(); });
        }
        condition_.notify_one();
        return result;
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex_);
            stop_ = true;
        }
        condition_.notify_all();
        for (std::thread &worker : workers_) {
            worker.join();
        }
    }

private:
    std::vector<std::thread> workers_;
    std::queue<std::function<void()>> tasks_;

    std::mutex queue_mutex_;
    std::condition_variable condition_;
    bool stop_;
};

登录后复制

使用示例

下面是简单使用方式，展示如何提交任务并获取结果：

#include <iostream>
#include <chrono>

int main() {
    ThreadPool pool(4); // 创建4个线程的线程池

    std::vector<std::future<int>> results;

    for (int i = 0; i < 8; ++i) {
        results.emplace_back(
            pool.enqueue([i] {
                std::this_thread::sleep_for(std::chrono::seconds(1));
                return i * i;
            })
        );
    }

    for (auto&& result : results) {
        std::cout << result.get() << ' ';
    }
    std::cout << std::endl;

    return 0;
}

登录后复制