Rust / 系统课时

隔离 CPU 密集计算

隔离 CPU 密集计算

异步运行时擅长等待网络、定时器和其他可挂起操作,却不会自动让压缩、哈希或大规模计算“变异步”。本篇把 CPU 密集任务移出 Tokio 工作线程,用 Rayon 线程池执行,并通过可等待结果安全回到异步流程。

学习目标

  • 判断哪些工作会长期占用 CPU,不能直接放进异步任务执行。
  • 根据并行计算与资源隔离需求选择 Rayon 全局池或专用线程池。
  • 使用 oneshot 把 CPU 计算结果接回 async 流程,并理解取消与并行度边界。

为什么 CPU 计算要离开异步工作线程

Tokio 的任务采用协作式调度:一个 Future 只有在执行到 .await 且当前操作尚未就绪时,才有机会把工作线程让给其他任务。纯计算循环如果几百毫秒都不等待,就会一直占着当前运行时线程;同一线程上的网络请求、定时器和其他任务因此延迟。

压缩、哈希、大量序列化、图像处理和复杂数值计算都属于典型 CPU 密集工作。把函数写成 async fn 并不能改变这一点,因为其中没有天然的挂起点。正确做法是建立明确的执行边界:Tokio 负责异步协调,CPU 线程池负责持续计算,结果再通过通道或其他可等待句柄返回。

Tokio 与 CPU 线程池的隔离边界

在 Rayon 与专用线程池之间选择

Rayon 适合能够拆分为独立子任务的 CPU 并行计算,例如对大量块执行压缩、哈希或映射归约。直接使用 Rayon 的全局线程池最省事,但全局池会被进程内所有 Rayon 工作共享;如果某类任务需要单独限制并行度、避免和其他计算互相挤占,可以用 ThreadPoolBuilder 建一个专用 Rayon 池。

专用池的线程数通常应围绕可用 CPU 核心数和服务整体负载设置,而不是按请求数无限增加。线程过多不会让固定 CPU 更快,反而会增加上下文切换和缓存竞争。对于很小的计算,也不要每个元素都跨线程提交一次,提交和唤醒成本可能比计算本身更高。

tokio::task::spawn_blocking 也能把同步函数移出异步工作线程,但它的线程池首先面向可能阻塞的工作。长时间、高并行的纯 CPU 计算更适合 Rayon 或显式受限的专用池;如果确实使用 spawn_blocking 跑 CPU 工作,也应额外限制并发量。

用可等待结果回到异步流程

下面建立一个 4 线程的专用 Rayon 池,在池中并行计算取模求和,再通过 Tokio 的 oneshot 通道把一次性结果送回异步任务。依赖配置是项目片段,放入 Cargo.toml 的 [dependencies] 后即可与后面的完整入口一起运行。

toml
[dependencies]
rayon = "1"
tokio = { version = "1", features = ["macros", "rt", "sync"] }

验证依赖是否生效的方法是执行 cargo run;Cargo 能完成解析和编译,且程序进入下面的 main,说明配置已加载。

rust
use rayon::prelude::*;
use tokio::sync::oneshot;

fn spawn_cpu_sum(pool: &rayon::ThreadPool, upper: u64) -> oneshot::Receiver<u64> {
    let (tx, rx) = oneshot::channel();

    pool.spawn(move || {
        // 持续占用 CPU 的循环只在 Rayon 工作者中执行。
        let sum = (0..=upper)
            .into_par_iter()
            .map(|n| n % 97)
            .sum::<u64>();

        // 一次性结果通过通道交还给异步侧。
        let _ = tx.send(sum);
    });

    rx
}

#[tokio::main(flavor = "current_thread")]
async fn main() {
    let pool = rayon::ThreadPoolBuilder::new()
        .num_threads(4)
        .build()
        .expect("build CPU pool");

    let result = spawn_cpu_sum(&pool, 1_000_000);

    // CPU 任务运行时,当前 async 流程仍可继续处理别的 Future。
    println!("async flow is still responsive");

    match result.await {
        Ok(value) => println!("cpu result = {value}"),
        Err(_) => eprintln!("cpu worker ended without a result"),
    }
}

预期输出

text
async flow is still responsive
cpu result = 47999082

这个结构的关键不是 oneshot 本身,而是“提交后立即返回 Receiver”。异步侧等待 Receiver 时可以挂起,Tokio 工作线程可去运行其他任务;真正持续占用 CPU 的部分始终留在 Rayon 池中。

控制取消和资源上限

丢弃 oneshot::Receiver 只表示调用方不再关心结果,并不会自动终止已经开始的 CPU 计算。对于可能运行数秒甚至更久的任务,需要把取消标记或取消令牌传入计算逻辑,并在合理的批次边界主动检查;不能指望取消一个 async Future 就强制停止普通线程中的函数。

因此,服务端通常同时控制两层上限:CPU 池本身的线程数,以及进入 CPU 池的任务数量。只要把持续计算留在受限线程池,并让结果通过可等待机制回到 Tokio,就能同时保住异步调度响应性和 CPU 资源的可预测性。

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

目录与阅读设置

阅读设置

17

记录一个想法

隔离 CPU 密集计算

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

登录哪都通