C / C++ / 系统课时
任务队列怎样安全关闭
任务队列怎样安全关闭
线程池关闭最容易出错的地方不是 join,而是关闭边界不明确:关闭同时仍接收新任务、队列未排空就让线程退出,或多个线程同时执行析构逻辑。安全关闭要把“拒绝新任务、排空旧任务、退出工作线程”定义成一个一致的状态转换。
学习目标
- 明确关闭过程中哪些任务应被接受、执行或拒绝
- 用同一同步边界消除提交与关闭之间的竞态
- 实现可重复调用、会排空已有任务的关闭流程
先定义关闭语义
这里采用常见的“优雅关闭”语义:进入关闭后立刻拒绝新任务;关闭前已经成功入队的任务继续执行;只有当队列为空时,工作线程才退出;管理线程最后 join 所有工作线程。

这个定义给并发提交一个清晰判定点:提交线程若先拿到锁并成功入队,该任务属于“已有任务”;关闭线程若先拿到锁并切换状态,之后的提交就必须失败。两种结果都合法,但不能出现状态已经关闭却仍悄悄入队的第三种结果。
提交和关闭必须共享同一把锁
下面的 C++17 实现用 accepting_ 控制是否接收新任务,用 stopping_ 唤醒工作线程进入排空阶段。二者都在 mutex_ 保护下修改,std::call_once 则保证多个调用方同时执行 close() 时只会有一个真正进入关闭流程。
#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';
}
}预期输出
existing=7
rejected: thread pool is closedclose() 返回前已经等待所有工作线程结束,因此 existing.get() 能取得关闭前任务的结果。关闭后的第二次提交会在入队前检查 accepting_,所以不会产生“任务已经进入队列,但再也没有线程处理”的悬空任务。
工作线程的退出条件要同时看状态和队列
错误写法常见于“只要 stopping_ 为真就立刻退出”。这样一来,关闭瞬间队列里仍存在的任务会被直接丢下。正确条件是:正在停止并且队列为空时才退出。
条件变量的谓词也必须包含 stopping_。否则当队列已经为空、所有工作线程都睡在 wait 上时,仅修改关闭状态并不能让它们自然醒来,所以 close() 还必须调用 notify_all()。
析构阶段要保证关闭只执行一次
显式 close() 和析构函数可能先后发生,也可能多个管理线程同时请求关闭。若每次都重复 join 同一批线程,行为就会失控。这里用 std::call_once 将关闭过程变成幂等操作:第一次调用完成状态切换、唤醒和 join,后续调用直接返回。
如果业务需要“立即取消未开始任务”,那是另一套语义,不能只把队列清空后仍假装是优雅关闭;等待这些任务 future 的调用方也需要收到明确取消结果。无论选择排空还是取消,关键都是先定义关闭契约,再让提交、工作线程和析构遵守同一个状态边界。