异步任务调度系统设计
面试考点
异步任务调度是并发编程的核心问题。面试官考察你是否理解线程池的设计、任务队列的选择、工作窃取(work stealing)策略、future/promise 异步结果获取,以及如何在任务依赖、优先级、取消等需求下设计可扩展的调度系统。
核心概念
异步任务调度系统的核心是把"任务的提交"和"任务的执行"解耦。提交者把任务放入队列,获得一个 future 用于获取结果;工作线程从队列中取出任务执行。线程池避免了反复创建/销毁线程的开销,任务队列实现了生产者-消费者模型。
架构概览
提交者1 ──┐ ┌── 工作线程1(本地队列)
提交者2 ──┼──→ [全局任务队列] ──分发──→ ├── 工作线程2(本地队列)
提交者3 ──┤ ├── 工作线程3(本地队列)
提交者N ──┘ └── 工作线程N(本地队列)
↕ 工作窃取基本示例
#include <iostream>
#include <vector>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <future>
#include <functional>
#include <atomic>
#include <memory>
#include <chrono>
#include <type_traits>
// ============================
// 线程安全任务队列
// ============================
class TaskQueue {
public:
// 放入任务
void push(std::function<void()> task) {
{
std::lock_guard<std::mutex> lock(mutex_);
tasks_.push(std::move(task));
}
cv_.notify_one();
}
// 取出任务(阻塞等待)
bool pop(std::function<void()>& task) {
std::unique_lock<std::mutex> lock(mutex_);
cv_.wait(lock, [this]() {
return !tasks_.empty() || stopped_;
});
if (stopped_ && tasks_.empty()) return false;
task = std::move(tasks_.front());
tasks_.pop();
return true;
}
// 尝试取出(非阻塞)
bool try_pop(std::function<void()>& task) {
std::lock_guard<std::mutex> lock(mutex_);
if (tasks_.empty()) return false;
task = std::move(tasks_.front());
tasks_.pop();
return true;
}
// 停止队列
void stop() {
{
std::lock_guard<std::mutex> lock(mutex_);
stopped_ = true;
}
cv_.notify_all();
}
size_t size() const {
std::lock_guard<std::mutex> lock(mutex_);
return tasks_.size();
}
private:
std::queue<std::function<void()>> tasks_;
mutable std::mutex mutex_;
std::condition_variable cv_;
bool stopped_ = false;
};
// ============================
// 线程池(核心调度器)
// ============================
class ThreadPool {
public:
// 创建线程池,默认使用硬件并发数
explicit ThreadPool(size_t num_threads = std::thread::hardware_concurrency()) {
for (size_t i = 0; i < num_threads; i++) {
workers_.emplace_back([this]() {
worker_loop();
});
}
}
~ThreadPool() {
shutdown();
}
// 提交任务,返回 future 获取结果
template<typename F, typename... Args>
auto submit(F&& f, Args&&... args)
-> std::future<std::invoke_result_t<F, Args...>>
{
using ReturnType = std::invoke_result_t<F, Args...>;
// 用 shared_ptr 包装 packaged_task,因为 std::function 要求可拷贝
auto task = std::make_shared<std::packaged_task<ReturnType()>>(
std::bind(std::forward<F>(f), std::forward<Args>(args)...)
);
std::future<ReturnType> result = task->get_future();
// 包装为 void() 放入队列
queue_.push([task]() { (*task)(); });
return result;
}
// 提交不关心结果的任务
template<typename F, typename... Args>
void submit_detach(F&& f, Args&&... args) {
queue_.push(
std::bind(std::forward<F>(f), std::forward<Args>(args)...)
);
}
// 获取线程数
size_t thread_count() const { return workers_.size(); }
// 获取待处理任务数
size_t pending_tasks() const { return queue_.size(); }
// 关闭线程池
void shutdown() {
if (stopped_.exchange(true)) return;
queue_.stop();
for (auto& worker : workers_) {
if (worker.joinable()) worker.join();
}
}
private:
void worker_loop() {
std::function<void()> task;
while (queue_.pop(task)) {
task();
}
}
std::vector<std::thread> workers_;
TaskQueue queue_;
std::atomic<bool> stopped_{false};
};
// ============================
// 使用示例
// ============================
// 模拟耗时计算
int heavy_computation(int x) {
std::this_thread::sleep_for(std::chrono::milliseconds(100));
return x * x;
}
void basic_demo() {
ThreadPool pool(4); // 4 个工作线程
// 提交多个任务
std::vector<std::future<int>> futures;
for (int i = 0; i < 10; i++) {
futures.push_back(pool.submit(heavy_computation, i));
}
// 收集结果
for (int i = 0; i < 10; i++) {
std::cout << i << "^2 = " << futures[i].get() << std::endl;
}
}
// ============================
// 延迟任务调度器
// ============================
class ScheduledExecutor {
public:
explicit ScheduledExecutor(size_t num_threads = 2)
: pool_(num_threads), running_(true) {
// 调度线程:检查定时任务是否到期
scheduler_ = std::thread([this]() { scheduler_loop(); });
}
~ScheduledExecutor() {
running_ = false;
cv_.notify_all();
if (scheduler_.joinable()) scheduler_.join();
}
// 延迟执行
template<typename F>
void schedule(F&& f, std::chrono::milliseconds delay) {
auto exec_time = std::chrono::steady_clock::now() + delay;
{
std::lock_guard<std::mutex> lock(mutex_);
scheduled_tasks_.push({exec_time, std::function<void()>(std::forward<F>(f))});
}
cv_.notify_one();
}
// 周期执行
template<typename F>
void schedule_periodic(F f, std::chrono::milliseconds period) {
// 递归调度:执行完后再调度下一次
schedule([this, f = std::move(f), period]() mutable {
f();
if (running_) {
schedule_periodic(std::move(f), period);
}
}, period);
}
private:
struct ScheduledTask {
std::chrono::steady_clock::time_point exec_time;
std::function<void()> task;
// 优先队列:最早到期的在前
bool operator>(const ScheduledTask& other) const {
return exec_time > other.exec_time;
}
};
void scheduler_loop() {
while (running_) {
std::unique_lock<std::mutex> lock(mutex_);
if (scheduled_tasks_.empty()) {
cv_.wait(lock, [this]() {
return !scheduled_tasks_.empty() || !running_;
});
if (!running_) break;
}
auto& top = scheduled_tasks_.top();
auto now = std::chrono::steady_clock::now();
if (top.exec_time <= now) {
// 到期了,提交给线程池执行
auto task = std::move(
const_cast<ScheduledTask&>(top).task
);
scheduled_tasks_.pop();
lock.unlock();
pool_.submit_detach(std::move(task));
} else {
// 等待到期或新任务到来
cv_.wait_until(lock, top.exec_time);
}
}
}
ThreadPool pool_;
std::thread scheduler_;
std::atomic<bool> running_;
std::mutex mutex_;
std::condition_variable cv_;
std::priority_queue<
ScheduledTask,
std::vector<ScheduledTask>,
std::greater<ScheduledTask>
> scheduled_tasks_;
};
void scheduled_demo() {
ScheduledExecutor executor(2);
std::cout << "提交延迟任务..." << std::endl;
executor.schedule([]() {
std::cout << "[500ms] 延迟任务执行" << std::endl;
}, std::chrono::milliseconds(500));
executor.schedule([]() {
std::cout << "[200ms] 延迟任务执行" << std::endl;
}, std::chrono::milliseconds(200));
executor.schedule([]() {
std::cout << "[1000ms] 延迟任务执行" << std::endl;
}, std::chrono::milliseconds(1000));
// 等待所有任务完成
std::this_thread::sleep_for(std::chrono::milliseconds(1500));
}
// ============================
// 任务依赖(简化版 DAG 调度)
// ============================
class TaskGraph {
public:
using TaskId = size_t;
// 添加任务
TaskId add_task(std::function<void()> task) {
TaskId id = tasks_.size();
tasks_.push_back({std::move(task), {}, 0});
return id;
}
// 添加依赖:task_id 依赖 dep_id
void add_dependency(TaskId task_id, TaskId dep_id) {
tasks_[dep_id].dependents.push_back(task_id);
tasks_[task_id].dep_count++;
}
// 执行所有任务(拓扑排序 + 并行执行)
void execute(ThreadPool& pool) {
std::vector<std::promise<void>> promises(tasks_.size());
std::vector<std::future<void>> futures;
for (auto& p : promises) {
futures.push_back(p.get_future());
}
// 找出所有没有依赖的任务
std::vector<TaskId> ready;
for (size_t i = 0; i < tasks_.size(); i++) {
if (tasks_[i].dep_count == 0) {
ready.push_back(i);
}
}
// 初始的无依赖任务
std::atomic<size_t> remaining{tasks_.size()};
std::mutex ready_mutex;
std::condition_variable ready_cv;
// 递归提交就绪任务
std::function<void(TaskId)> submit_task;
submit_task = [&](TaskId id) {
pool.submit_detach([&, id]() {
// 执行任务
tasks_[id].task();
promises[id].set_value();
// 通知依赖此任务的后续任务
for (TaskId dep : tasks_[id].dependents) {
if (--tasks_[dep].dep_count == 0) {
submit_task(dep);
}
}
remaining--;
ready_cv.notify_all();
});
};
for (TaskId id : ready) {
submit_task(id);
}
// 等待所有任务完成
std::unique_lock<std::mutex> lock(ready_mutex);
ready_cv.wait(lock, [&]() {
return remaining.load() == 0;
});
}
private:
struct TaskNode {
std::function<void()> task;
std::vector<TaskId> dependents; // 依赖此任务的后续任务
std::atomic<int> dep_count; // 未完成的前置依赖数
};
std::vector<TaskNode> tasks_;
};
void dag_demo() {
ThreadPool pool(4);
TaskGraph graph;
// 构建任务依赖图:
// A → C
// B → C
// C → D
auto a = graph.add_task([]() {
std::cout << "任务A执行" << std::endl;
});
auto b = graph.add_task([]() {
std::cout << "任务B执行" << std::endl;
});
auto c = graph.add_task([]() {
std::cout << "任务C执行(依赖A和B)" << std::endl;
});
auto d = graph.add_task([]() {
std::cout << "任务D执行(依赖C)" << std::endl;
});
graph.add_dependency(c, a); // C 依赖 A
graph.add_dependency(c, b); // C 依赖 B
graph.add_dependency(d, c); // D 依赖 C
graph.execute(pool);
}
int main() {
std::cout << "=== 基本线程池 ===" << std::endl;
basic_demo();
std::cout << "\n=== 延迟调度 ===" << std::endl;
scheduled_demo();
std::cout << "\n=== 任务依赖图 ===" << std::endl;
dag_demo();
return 0;
}调度策略对比
| 策略 | 机制 | 优点 | 缺点 |
|---|---|---|---|
| 全局队列 | 所有线程共享一个队列 | 实现简单 | 锁竞争严重 |
| 本地队列 | 每个线程有自己的队列 | 低竞争 | 可能负载不均 |
| 工作窃取 | 空闲线程从忙碌线程偷任务 | 自动负载均衡 | 实现复杂 |
| 优先级队列 | 按优先级取任务 | 重要任务优先 | 低优先级可能饿死 |
关键设计决策
| 决策 | 选项 | 考虑因素 |
|---|---|---|
| 线程数 | 固定 / 动态 | CPU 核数、任务类型(CPU/IO) |
| 队列类型 | 有锁 / 无锁 | 性能 vs 复杂度 |
| 任务类型 | std::function / 模板 | 灵活性 vs 性能 |
| 结果获取 | future / 回调 / 协程 | 易用性 vs 开销 |
| 异常处理 | 传播到 future / 记录 | 安全性 vs 性能 |
常见问题
线程数应该设置为多少?
CPU 密集型任务设为 CPU 核心数(std:🧵:hardware_concurrency())。I/O 密集型任务可以设为核心数的 2-4 倍,因为线程大部分时间在等待 I/O。混合型可以用两个线程池:一个给 CPU 任务,一个给 I/O 任务。
std::function 的开销大吗?
std::function 有类型擦除的开销:小于一定大小(通常 16-32 字节)的可调用对象用 SBO(小缓冲区优化),否则堆分配。如果性能敏感,可以用模板直接存储可调用对象,或使用 unique_function(move-only function)。
工作窃取是怎么实现的?
每个线程维护一个双端队列(deque)。线程从自己队列的一端取任务(LIFO,利用缓存局部性),空闲时从其他线程队列的另一端偷任务(FIFO,偷大粒度任务)。关键是偷取操作需要是线程安全的,通常用 atomic 操作实现。
适用场景
- Web 服务器的请求处理
- 批量数据处理(MapReduce 风格)
- 游戏引擎的帧任务调度
- 编译系统的并行编译
- 定时任务(cron 风格)
注意事项
- 线程池的生命周期必须长于所有提交的任务
- 任务中不要阻塞等待其他任务的结果(可能死锁)
- std::packaged_task 不可拷贝,需要 shared_ptr 包装
- 异常在工作线程中抛出,需要通过 future 传播
- 关闭线程池时要等待所有任务完成
总结
异步任务调度系统的核心是线程池 + 任务队列。线程池管理固定数量的工作线程,任务队列实现生产者-消费者解耦。高级特性包括延迟调度(优先队列按到期时间排序)、任务依赖(DAG 拓扑排序 + 并行执行)、工作窃取(自动负载均衡)。面试中要能实现基本的线程池,解释 submit 如何通过 packaged_task + future 返回异步结果,讨论线程数选择、队列策略、以及工作窃取的原理。