异步运行时由什么组成

主线位置：这一章不在任何一条主线的某一段上，它给出两条主线共用的三个部件。

从 Future 的契约说起

Rust 标准库只定义了 Future trait 和 Waker，没有自带运行时。Future 的契约很简单：

1. 有人调用 poll。能完成就返回 Ready(v)。
2. 还不能完成，就把 cx.waker() 存到「将来会发生事件的地方」，然后返回 Pending。
3. 事件发生时，那个地方调用 waker.wake()。之后应该有人再 poll 一次。

契约里有三个空缺需要运行时来填：

反应器和定时器是事件的来源，执行器消费事件：它们调用 wake()，执行器把对应的任务重新放进队列。

flowchart LR
  subgraph exec[执行器]
    Q[任务队列] --> W[worker 线程 poll 任务]
  end
  W -->|Pending，存下 waker| R[反应器：epoll / kqueue / IOCP]
  W -->|Pending，存下 waker| T[定时器：时间轮]
  R -->|wake| Q
  T -->|wake| Q

三件套在 tokio 里怎么装在一起

反应器和定时器都需要「等」：等 IO 事件，或者等到某个时刻。tokio 没有给它们单开线程，而是让空闲的 worker 线程亲自去等。worker 没有任务可跑时，会调用驱动的 park，最终阻塞在 epoll_wait（或 kqueue、IOCP）上，超时时间设为最近一个定时器的到期时间。

所以驱动是一层套一层的。Driver::new：

pub(crate) fn new(cfg: Cfg) -> io::Result<(Self, Handle)> {
    let (io_stack, io_handle, signal_handle) =
        create_io_stack(cfg.enable_io, cfg.nevents, cfg.nevents_busy)?;

    let clock = create_clock(cfg.enable_pause_time, cfg.start_paused);

    let (time_driver, time_handle) =
        create_time_driver(cfg.enable_time, cfg.timer_flavor, io_stack, &clock);

    Ok((
        Self { inner: time_driver },
        // ...
    ))
}

最外层是时间驱动，它包着 IO 栈（IO 驱动外面还套着信号和子进程的驱动）。park 时，时间驱动先算出最近一个定时器还有多久到期，然后用这个时长去 park 里层的 IO 驱动；醒来后，再处理已经到期的定时器。如果构建时没开 IO（没调 enable_io），IO 栈就退化成 ParkThread，用条件变量等待。这一套留到驱动栈与 park细讲。

多线程运行时有好几个 worker，但驱动只有一份。它放在一个 TryLock 里（multi_thread/park.rs 第 53 行）：哪个空闲 worker 先抢到锁，就由它去 epoll_wait；其他空闲 worker 在各自的条件变量上睡觉，等有新任务时再被叫醒。

执行器：多线程加任务窃取

多线程调度器启动 N 个 worker 线程，N 默认等于 CPU 核数，可以用 Builder::worker_threads 或环境变量 TOKIO_WORKER_THREADS 改。每个 worker 有：

• 一个容量 256 的本地队列，只有自己能往里放，别的 worker 可以从里面偷。
• 一个 LIFO 槽，放最近一个被唤醒的任务，下一个优先跑它。

所有 worker 还共享一个带锁的注入队列，从非 worker 线程 spawn 的任务放在这里。

worker 自己的活干完了，就去别的 worker 的本地队列偷一半过来。这就是任务窃取（work stealing）。它的好处是负载自动均衡：某个连接特别忙，它产生的任务会被闲着的线程分走。代价是任务必须能在线程间移动，所以 tokio::spawn 要求 F: Send + 'static。

另一条路：每核一个线程

同样是 Rust 的异步运行时，架构上分成两派：

每核一个线程（thread-per-core）的思路是：每个线程绑一个核，各自有独立的反应器和任务队列，任务在哪个线程创建就一直在哪个线程跑。

• 好处：任务不跨线程，所以不需要 Send，可以随便用 Rc、RefCell；没有跨核的同步开销，缓存也一直是热的。配合 io_uring，适合存储、代理这类每个连接负载比较均匀的场景。
• 代价：负载不均时没有补救。一个线程上的连接特别忙，别的核再闲也帮不上忙。

tokio 选择任务窃取，是因为它的目标是「通用」：大多数网络服务的连接负载不均匀，开发者也不想为每个任务考虑它该放在哪个核上。tokio 也给出了每核一线程的写法：current_thread 运行时加 LocalSet（或 LocalRuntime）跑 !Send 的任务，每个线程开一个这样的运行时。这些取舍在「09 设计取舍」里汇总。

小结

• 运行时 = 执行器（谁来 poll）+ 反应器（IO 事件）+ 定时器（时间事件）。反应器和定时器负责调用 wake()，执行器负责重新 poll。
• tokio 不给驱动单开线程：空闲的 worker 去 park 在驱动上，驱动是「时间驱动包着 IO 驱动」的一层层结构。
• 多线程运行时只有一份驱动，用 TryLock 保护，谁抢到谁去等 IO。
• tokio 用多线程任务窃取换来负载均衡，代价是任务要 Send；glommio、monoio 走每核一线程，换来无锁和缓存友好。