异步任务调度系统设计 ​

面试考点 ​

异步任务调度是并发编程的核心问题。面试官考察你是否理解线程池的设计、任务队列的选择、工作窃取(work stealing)策略、future/promise 异步结果获取,以及如何在任务依赖、优先级、取消等需求下设计可扩展的调度系统。

核心概念 ​

异步任务调度系统的核心是把"任务的提交"和"任务的执行"解耦。提交者把任务放入队列,获得一个 future 用于获取结果;工作线程从队列中取出任务执行。线程池避免了反复创建/销毁线程的开销,任务队列实现了生产者-消费者模型。

架构概览 ​

提交者1 ──┐                                   ┌── 工作线程1(本地队列)
提交者2 ──┼──→ [全局任务队列] ──分发──→ ├── 工作线程2(本地队列)
提交者3 ──┤                                   ├── 工作线程3(本地队列)
提交者N ──┘                                   └── 工作线程N(本地队列)
                                                     ↕ 工作窃取

基本示例 ​

cpp
#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 返回异步结果,讨论线程数选择、队列策略、以及工作窃取的原理。