Rust / 系统课时

诊断延迟与吞吐问题

诊断延迟与吞吐问题

延迟升高和吞吐下降常常同时出现,但原因可能分别来自运行时线程被阻塞、任务堆积、通道背压、锁竞争或缓冲过大。本篇建立固定诊断顺序,并用一个可运行的小型流水线同时采集调度延迟、并发任务数、发送等待和锁等待,避免只调一个参数就碰运气。

学习目标

  • 按“调度线程 → 任务数量 → 通道 → 锁 → 缓冲”的顺序定位性能瓶颈
  • 用可重复负载和同一组指标比较修复前后,而不是只观察平均耗时
  • 识别扩大任务数、通道容量或缓冲区可能掩盖背压并放大尾延迟的场景

先固定诊断顺序

第一步先确认工作线程是否被同步阻塞或长时间计算占满,因为这会让后续所有异步指标一起恶化。第二步看任务数量是否持续增长;任务增长通常说明入口速度高于完成速度,不能简单理解为“并发越高越好”。第三步再看有界通道发送等待,确认背压出现在哪里。

随后检查锁等待和临界区长度。如果大量任务都在等同一个锁,应先缩短持锁范围,而不是增加 worker 数。最后才调整通道容量、批量大小和 flush 周期:更大的缓冲能吸收短突发,但也可能让请求在队列里停留更久。

Tokio 性能问题的固定诊断顺序

用一个流水线同时采证据

示例使用容量为 16 的 mpsc 作为入口缓冲,用 Semaphore 把活动工作任务限制为 8 个,并记录发送等待、锁等待、心跳调度延迟和最大活动任务数。bad 模式故意在异步任务里持锁执行 std::thread::sleep;good 模式缩短持锁范围,并把模拟等待改成异步定时器。

toml
[package]
name = "tokio-perf-diagnose"
version = "0.1.0"
edition = "2021"

[dependencies]
tokio = { version = "1", features = ["full"] }

该配置只引入示例需要的 Tokio 能力;下面的运行命令会同时完成编译验证。

rust
use std::{
    env,
    sync::{
        atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering},
        Arc,
    },
    time::Duration,
};
use tokio::{
    sync::{mpsc, Mutex, Semaphore},
    task::JoinSet,
    time::Instant,
};

const JOBS: u64 = 80;
const CHANNEL_CAPACITY: usize = 16;
const CONCURRENCY: usize = 8;

#[derive(Clone, Copy)]
enum Mode {
    Bad,
    Good,
}

impl Mode {
    fn name(self) -> &'static str {
        match self {
            Mode::Bad => "bad",
            Mode::Good => "good",
        }
    }
}

#[tokio::main(flavor = "multi_thread", worker_threads = 1)]
async fn main() {
    let mode = match env::args().nth(1).as_deref() {
        Some("bad") => Mode::Bad,
        _ => Mode::Good,
    };
    run(mode).await;
}

async fn run(mode: Mode) {
    let (tx, mut rx) = mpsc::channel::<u64>(CHANNEL_CAPACITY);
    let shared = Arc::new(Mutex::new(0_u64));
    let slots = Arc::new(Semaphore::new(CONCURRENCY));

    let active = Arc::new(AtomicUsize::new(0));
    let max_active = Arc::new(AtomicUsize::new(0));
    let max_send_wait = Arc::new(AtomicU64::new(0));
    let max_lock_wait = Arc::new(AtomicU64::new(0));
    let max_heartbeat_lag = Arc::new(AtomicU64::new(0));
    let stop = Arc::new(AtomicBool::new(false));

    // 心跳延迟近似反映 runtime worker 无法及时重新调度任务的程度。
    let heartbeat_lag = max_heartbeat_lag.clone();
    let heartbeat_stop = stop.clone();
    let heartbeat = tokio::spawn(async move {
        while !heartbeat_stop.load(Ordering::Relaxed) {
            let started = Instant::now();
            tokio::time::sleep(Duration::from_millis(10)).await;
            let lag = started
                .elapsed()
                .saturating_sub(Duration::from_millis(10));
            heartbeat_lag.fetch_max(lag.as_micros() as u64, Ordering::Relaxed);
        }
    });

    let send_wait = max_send_wait.clone();
    let producer = tokio::spawn(async move {
        for job in 0..JOBS {
            let started = Instant::now();
            tx.send(job).await.expect("receiver must stay alive");
            send_wait.fetch_max(started.elapsed().as_micros() as u64, Ordering::Relaxed);
        }
    });

    let started = Instant::now();
    let mut tasks = JoinSet::new();

    while let Some(job) = rx.recv().await {
        // 在 spawn 前取得许可,避免把“限流”写进任务内部后仍创建海量等待任务。
        let permit = slots.clone().acquire_owned().await.unwrap();
        let shared = shared.clone();
        let active = active.clone();
        let max_active = max_active.clone();
        let lock_wait = max_lock_wait.clone();

        tasks.spawn(async move {
            let now = active.fetch_add(1, Ordering::Relaxed) + 1;
            max_active.fetch_max(now, Ordering::Relaxed);

            match mode {
                Mode::Bad => {
                    let lock_started = Instant::now();
                    let mut guard = shared.lock().await;
                    lock_wait.fetch_max(
                        lock_started.elapsed().as_micros() as u64,
                        Ordering::Relaxed,
                    );
                    // 故意阻塞唯一 worker,并把阻塞时间放大到锁临界区。
                    std::thread::sleep(Duration::from_millis(5));
                    *guard += job;
                }
                Mode::Good => {
                    let lock_started = Instant::now();
                    {
                        let mut guard = shared.lock().await;
                        lock_wait.fetch_max(
                            lock_started.elapsed().as_micros() as u64,
                            Ordering::Relaxed,
                        );
                        *guard += job;
                    }
                    tokio::time::sleep(Duration::from_millis(5)).await;
                }
            }

            active.fetch_sub(1, Ordering::Relaxed);
            drop(permit);
        });

        while let Some(result) = tasks.try_join_next() {
            result.expect("worker task panicked");
        }
    }

    producer.await.expect("producer panicked");
    while let Some(result) = tasks.join_next().await {
        result.expect("worker task panicked");
    }

    stop.store(true, Ordering::Relaxed);
    heartbeat.await.expect("heartbeat panicked");

    println!(
        "mode={} elapsed_ms={} max_active={} max_send_wait_us={} max_lock_wait_us={} max_heartbeat_lag_us={}",
        mode.name(),
        started.elapsed().as_millis(),
        max_active.load(Ordering::Relaxed),
        max_send_wait.load(Ordering::Relaxed),
        max_lock_wait.load(Ordering::Relaxed),
        max_heartbeat_lag.load(Ordering::Relaxed),
    );
}

预期结果

text
程序接受 bad 或 good 模式参数,并输出 elapsed、活动任务数、发送等待、锁等待和心跳调度延迟。

在同一台机器、同一构建配置下连续运行两种模式:

bash
cargo run -- bad
cargo run -- good

预期输出

text
mode=bad elapsed_ms=<TIME> max_active=<COUNT> max_send_wait_us=<TIME> max_lock_wait_us=<TIME> max_heartbeat_lag_us=<TIME>
mode=good elapsed_ms=<TIME> max_active=<COUNT> max_send_wait_us=<TIME> max_lock_wait_us=<TIME> max_heartbeat_lag_us=<TIME>

数值受机器负载影响,不应比较绝对值。这个受控示例里,bad 通常会出现更大的心跳延迟、锁等待和发送等待;good 让模拟等待主动让出 worker,并避免在等待期间持锁,因此同一批 80 个任务应更快排空。

把指标映射到根因

如果心跳延迟明显升高,先搜索异步上下文里的同步文件 I/O、同步网络调用、std::thread::sleep 或长时间 CPU 计算。可替换成真正异步 API 的优先替换;必须调用阻塞 API 时,把有界、会结束的工作放进 tokio::task::spawn_blocking,并对大量 CPU 密集工作额外限制并行度。

如果 max_active 长期顶住并发上限,同时发送等待继续上升,瓶颈在消费侧而不是通道太小。此时扩大 CHANNEL_CAPACITY 只会允许更多请求排队。相反,如果负载只是短促突发、消费者很快追上,适度缓冲才可能降低入口抖动。

如果锁等待高但心跳正常,重点看临界区:是否跨 .await、是否把序列化/格式化等计算也放在锁内、是否可以按 key 分片状态。增加任务数通常会让锁竞争更严重,不会提升吞吐。

调整缓冲时同时看尾延迟

缓冲策略必须和延迟目标一起验证。增大 channel、批量聚合或延迟 flush 往往可以减少调度和 I/O 次数,却也增加单个请求在队列中的停留时间。每次只改一个变量,并用同一负载比较吞吐、p95/p99、发送等待、锁等待和内存占用,才能知道优化究竟移动了瓶颈还是消除了瓶颈。

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

目录与阅读设置

阅读设置

17

记录一个想法

诊断延迟与吞吐问题

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

登录哪都通