c++中如何实现一个简单的线程池_c++线程池实现思路与示例

答案：C++线程池通过预创建线程、任务队列和同步机制实现高效任务调度，核心包括线程组、std::queue存储任务、std::mutex与condition_variable保障线程安全，支持RAII管理资源，可复用线程避免频繁创建开销。

在C++中实现一个简单的线程池，核心思路是预先创建一组工作线程，通过任务队列接收外部提交的任务，由空闲线程自动从队列中取出并执行。这种方式避免了频繁创建和销毁线程的开销，提高程序性能。

线程池的基本组成

一个基本的线程池通常包含以下几个部分：

• 线程组： 一组等待任务的工作线程。
• 任务队列： 存放待执行任务的容器，通常使用队列结构（如std::queue）。
• 互斥锁与条件变量： 保护任务队列的线程安全，并实现线程间的同步唤醒。
• 控制开关： 标记线程池是否运行，用于优雅关闭。

任务的定义与存储

任务一般以可调用对象的形式存在，比如函数、lambda表达式或函数对象。可以使用std::function统一包装这些类型。

示例：

#include 
#include 

using Task = std::function;
std::queue tasks_;

这样就可以把不同形式的任务都存入同一个队列中。

线程同步机制

多个线程访问共享任务队列时必须加锁。使用std::mutex保护队列，再配合std::condition_variable实现“有任务就通知线程”的机制。

关键代码片段：

std::mutex mtx_;
std::condition_variable cv_;
bool stop_ = false;

// 添加任务
void enqueue(Task task) {
    std::unique_lock lock(mtx_);
    tasks_.push(std::move(task));
    cv_.notify_one(); // 唤醒一个线程
}

// 工作线程循环
void worker() {
    while (true) {
        std::unique_lock lock(mtx_);
        cv_.wait(lock, [this] { return !tasks_.empty() || stop_; });
        
        if (stop_ && tasks_.empty()) break;

        Task task = std::move(tasks_.front());
        tasks_.pop();
        lock.unlock();

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

线程池类的简单实现

将上述组件整合成一个完整的类：

#include 
#include 
#include 
#include 
#include 
#include 
#include 

class ThreadPool {
public:
    explicit ThreadPool(size_t threads) : stop_(false) {
        for (size_t i = 0; i < threads; ++i) {
            workers_.emplace_back([this] {
                worker();
            });
        }
    }

    ~ThreadPool() {
        {
            std::unique_lock lock(mtx_);
            stop_ = true;
        }
        cv_.notify_all();
        for (auto& t : workers_) {
            t.join();
        }
    }

    void enqueue(Task task) {
        std::unique_lock lock(mtx_);
        tasks_.push(std::move(task));
        cv_.notify_one();
    }

private:
    using Task = std::function;
    std::vector workers_;
    std::queue tasks_;
    std::mutex mtx_;
    std::condition_variable cv_;
    bool stop_;

    void worker() {
        while (true) {
            std::unique_lock lock(mtx_);
            cv_.wait(lock, [this] { return !tasks_.empty() || stop_; });
            if (stop_ && tasks_.empty()) return;
            Task task = std::move(tasks_.front());
            tasks_.pop();
            lock.unlock();
            task();
        }
    }
};

使用示例

提交一些简单任务测试线程池：

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

    for (int i = 0; i < 8; ++i) {
        pool.enqueue([i] {
            std::cout << "任务 " << i << " 正在执行，线程ID: "
                      << std::this_thread::get_id() << '\n';
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        });
    }

    // 主函数退出前，pool析构会等待所有任务完成
    return 0;
}

这段代码会看到8个任务被4个线程并发处理，输出顺序不固定但总能完成。

基本上就这些。这个线程池虽然简单，但具备了核心功能：复用线程、安全添加任务、自动调度执行、支持RAII资源管理。进一步可以扩展支持返回值（结合std::future）、动态调整线程数等，但对大多数场景来说，这个版本已经够用。