C / C++ / 系统课时

任务队列怎样安全关闭

任务队列怎样安全关闭

线程池关闭最容易出错的地方不是 join,而是关闭边界不明确:关闭同时仍接收新任务、队列未排空就让线程退出,或多个线程同时执行析构逻辑。安全关闭要把“拒绝新任务、排空旧任务、退出工作线程”定义成一个一致的状态转换。

学习目标

  • 明确关闭过程中哪些任务应被接受、执行或拒绝
  • 用同一同步边界消除提交与关闭之间的竞态
  • 实现可重复调用、会排空已有任务的关闭流程

先定义关闭语义

这里采用常见的“优雅关闭”语义:进入关闭后立刻拒绝新任务;关闭前已经成功入队的任务继续执行;只有当队列为空时,工作线程才退出;管理线程最后 join 所有工作线程。

线程池安全关闭状态与任务处理流程

这个定义给并发提交一个清晰判定点:提交线程若先拿到锁并成功入队,该任务属于“已有任务”;关闭线程若先拿到锁并切换状态,之后的提交就必须失败。两种结果都合法,但不能出现状态已经关闭却仍悄悄入队的第三种结果。

提交和关闭必须共享同一把锁

下面的 C++17 实现用 accepting_ 控制是否接收新任务,用 stopping_ 唤醒工作线程进入排空阶段。二者都在 mutex_ 保护下修改,std::call_once 则保证多个调用方同时执行 close() 时只会有一个真正进入关闭流程。

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

class DrainingThreadPool {
public:
    explicit DrainingThreadPool(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 (!accepting_) {
                throw std::runtime_error("thread pool is closed");
            }
            tasks_.push([task] { (*task)(); });
        }

        cv_.notify_one();
        return result;
    }

    void close() {
        std::call_once(close_once_, [this] {
            {
                std::lock_guard<std::mutex> lock(mutex_);
                accepting_ = false;
                stopping_ = true;
            }

            cv_.notify_all();

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

    ~DrainingThreadPool() {
        close();
    }

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

int main() {
    DrainingThreadPool pool(1);

    auto existing = pool.submit([] {
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
        return 7;
    });

    pool.close();
    std::cout << "existing=" << existing.get() << '\n';

    try {
        pool.submit([] { return 9; });
    } catch (const std::runtime_error& ex) {
        std::cout << "rejected: " << ex.what() << '\n';
    }
}

预期输出

text
existing=7
rejected: thread pool is closed

close() 返回前已经等待所有工作线程结束,因此 existing.get() 能取得关闭前任务的结果。关闭后的第二次提交会在入队前检查 accepting_,所以不会产生“任务已经进入队列,但再也没有线程处理”的悬空任务。

工作线程的退出条件要同时看状态和队列

错误写法常见于“只要 stopping_ 为真就立刻退出”。这样一来,关闭瞬间队列里仍存在的任务会被直接丢下。正确条件是:正在停止并且队列为空时才退出。

条件变量的谓词也必须包含 stopping_。否则当队列已经为空、所有工作线程都睡在 wait 上时,仅修改关闭状态并不能让它们自然醒来,所以 close() 还必须调用 notify_all()。

析构阶段要保证关闭只执行一次

显式 close() 和析构函数可能先后发生,也可能多个管理线程同时请求关闭。若每次都重复 join 同一批线程,行为就会失控。这里用 std::call_once 将关闭过程变成幂等操作:第一次调用完成状态切换、唤醒和 join,后续调用直接返回。

如果业务需要“立即取消未开始任务”,那是另一套语义,不能只把队列清空后仍假装是优雅关闭;等待这些任务 future 的调用方也需要收到明确取消结果。无论选择排空还是取消,关键都是先定义关闭契约,再让提交、工作线程和析构遵守同一个状态边界。

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

目录与阅读设置

阅读设置

17

记录一个想法

任务队列怎样安全关闭

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

登录哪都通