C / C++ / 系统课时

线程池的核心结构有哪些

线程池的核心结构有哪些

一个最小线程池不需要复杂调度器,关键是把“提交任务”和“执行任务”解耦。掌握任务队列、工作线程、互斥锁、条件变量与停止标志之间的协作后,就能读懂多数线程池实现的基本骨架。

学习目标

  • 识别线程池中任务队列、工作线程、条件变量和停止标志的职责
  • 理解提交线程与工作线程之间的数据流和同步边界
  • 用 C++17 实现并验证一个可运行的最小线程池

最小线程池由哪些部件组成

任务提交方只负责把任务放进队列,工作线程则长期循环:等待任务、取出任务、释放锁、执行任务。互斥锁保护队列和停止状态,条件变量让空闲线程睡眠而不是反复轮询。

线程池核心结构与任务流向

这几个部件必须形成一个整体。只加线程而没有共享队列,任务无法统一调度;只有队列而没有条件变量,工作线程通常只能忙等;停止标志若不受同一把锁保护,又会在析构时引入竞态。

用最小实现把结构串起来

下面的 C++17 示例固定接收返回 int 的任务,目的是突出线程池结构本身。任务被包装成 std::packaged_task,因此提交方可以通过 std::future 取得结果或异常。

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

class ThreadPool {
public:
    explicit ThreadPool(std::size_t worker_count) {
        for (std::size_t i = 0; i < worker_count; ++i) {
            workers_.emplace_back([this] {
                for (;;) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(mutex_);
                        cv_.wait(lock, [this] {
                            return stopping_ || !tasks_.empty();
                        });

                        if (stopping_ && tasks_.empty()) {
                            return;
                        }

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

                    // 执行任务时不持有队列锁,避免阻塞其他线程提交或取任务。
                    task();
                }
            });
        }
    }

    std::future<int> submit(std::function<int()> job) {
        auto task =
            std::make_shared<std::packaged_task<int()>>(std::move(job));
        std::future<int> result = task->get_future();

        {
            std::lock_guard<std::mutex> lock(mutex_);
            if (stopping_) {
                throw std::runtime_error("thread pool is stopping");
            }
            tasks_.push([task] { (*task)(); });
        }

        cv_.notify_one();
        return result;
    }

    ~ThreadPool() {
        {
            std::lock_guard<std::mutex> lock(mutex_);
            stopping_ = true;
        }
        cv_.notify_all();

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

private:
    std::mutex mutex_;
    std::condition_variable cv_;
    std::queue<std::function<void()>> tasks_;
    std::vector<std::thread> workers_;
    bool stopping_ = false;
};

int main() {
    ThreadPool pool(2);

    auto left = pool.submit([] { return 20; });
    auto right = pool.submit([] { return 22; });

    std::cout << "sum=" << left.get() + right.get() << '\n';
}

预期输出

text
sum=42

编译时可使用支持 C++17 的编译器,例如 g++ -std=c++17 -pthread main.cpp。线程实际执行先后可能不同,但两个 future 都完成后,最终输出保持一致。

锁和条件变量的边界最关键

cv_.wait 必须在持有互斥锁时检查谓词,因为“队列是否为空”和“是否正在停止”都属于共享状态。唤醒后再次检查谓词还能正确处理虚假唤醒。

从队列取出任务后应立即释放锁,再执行任务。如果把 task() 放在临界区内,一个耗时任务会阻止其他工作线程取任务,也会阻塞新的任务提交,线程池就会退化成接近串行执行。

这个骨架什么时候还不够

真实服务通常还会补上有界队列、拒绝策略、任务取消、优先级、监控指标或动态扩缩容。它们都建立在相同核心关系上:提交方只修改受保护的共享状态,工作线程通过条件变量等待状态变化,并在不持有队列锁时执行任务。

最小实现的价值不是直接替代成熟线程池,而是帮助你定位并发问题:任务是否成功入队、工作线程是否被唤醒、锁是否持有过久,以及停止状态是否能让线程最终退出。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

线程池的核心结构有哪些

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通