导出按钮点下去,窗口标题栏立刻变成「未响应」,鼠标移过去是转圈,用户只能等,或者强行结束进程。改成后台线程以后,界面不卡了,但新的抱怨来了:点了取消,进度还在走;关掉窗口,任务管理器里进程还在;任务明明失败了,界面却一直停在「正在导出」。

这三个现象分别对应三件没做好的事:任务没有真正离开界面线程;取消只是一个按钮,没有传达到正在干活的循环;任务的结束状态没有可靠地回到界面。桌面程序的长任务不是「开个线程」就完事,它是一条完整的生命周期:启动、报进度、可取消、成功或失败、清理资源。这篇用一个能跑的目录扫描实验把这套生命周期走一遍,再把 Tauri 里的分工讲清楚。

为什么界面会卡

界面线程(也叫主线程、UI 线程)的工作是处理事件:鼠标、键盘、重绘、窗口消息。它必须快速返回,才能继续处理下一个事件。你在它上面跑一个两秒的循环,这两秒里所有事件都排队,系统就会认为程序失去响应,标题栏变灰,用户点击没有反馈。

所以规则只有一条:耗时操作不能占着界面线程。判断「耗时」的标准不是代码行数,而是有没有等待:读大文件、遍历几万个目录、网络请求、压缩、加密,都属于这一类。哪怕只有两百毫秒,只要用户在这段时间里连续点击,体验就会变差。

在 Tauri 里,同步命令默认在界面线程上执行。你在命令函数里写一个遍历十万个文件的循环,窗口一定会卡。把命令声明成 async 可以让它不占用界面线程,但真正吃 CPU 的循环还应该放进阻塞线程池,否则会拖慢异步运行时的其他任务。

本机在 Tauri 里测过的同步命令只有 greet:从 invoke 发出到 Promise 兑现,往返 7.9 毫秒。它快是因为函数只做字符串拼接,没有任何等待。把同样的写法换成一个遍历目录的循环,界面线程一样会被占住,只是你未必能在 7.9 毫秒这个量级上看出来。判断命令有没有问题,不能看「平时快不快」,要看「最慢的那一次卡了多久」。

一个能跑的后台任务

下面这段程序模拟一个耗时一百步的任务,同时让界面线程每 50 毫秒心跳一次,并在中途取消。它只用标准库,完整可编译。程序里的 100 步、每步 10 毫秒都是人为设定,不是性能基准,只是让取消有足够的时间窗口:

use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::channel;
use std::sync::Arc;
use std::thread;
use std::time::{Duration, Instant};

fn main() {
    let cancel = Arc::new(AtomicBool::new(false));
    let (tx, rx) = channel::<u32>();
    let flag = Arc::clone(&cancel);
    let start = Instant::now();

    let worker = thread::spawn(move || {
        for step in 0..=100u32 {
            if flag.load(Ordering::Relaxed) {
                break;
            }
            thread::sleep(Duration::from_millis(10));
            if step % 10 == 0 {
                tx.send(step).unwrap();
            }
        }
        tx.send(999).unwrap();
    });

    // 模拟 UI 线程:每 50ms 心跳一次,观察最长间隔
    let mut last = start.elapsed();
    let mut max_gap = Duration::ZERO;
    for _ in 0..12 {
        thread::sleep(Duration::from_millis(50));
        let now = start.elapsed();
        let gap = now - last;
        if gap > max_gap {
            max_gap = gap;
        }
        last = now;
    }

    cancel.store(true, Ordering::Relaxed);
    worker.join().unwrap();

    let mut seen = Vec::new();
    for p in rx.try_iter() {
        seen.push(p);
    }
    println!("[ui] heartbeat max gap = {:?}", max_gap);
    println!("[worker] progress events = {:?}", seen);
    println!("[worker] elapsed = {:?}", start.elapsed());
}
rustc -O worker_cancel.rs
.\worker_cancel.exe
[ui] heartbeat max gap = 50.5677ms
[worker] progress events = [0, 10, 20, 30, 40, 50, 999]
[worker] elapsed = 605.954ms

输出里的毫秒数来自一次真实运行,重复执行会有几毫秒浮动。三个关键信息是:第一,界面线程的最长间隔是 50.5677 毫秒,几乎等于设定的 50 毫秒,说明它没有被后台任务拖住;如果任务跑在界面线程上,这个间隔会变成几百毫秒甚至几秒。第二,进度事件只到 50,因为第 12 次心跳、大约 600 毫秒时取消了任务,循环在下一次检查时退出,没有继续跑到 100。第三,最后那个 999 是约定好的结束标记,前端收到它就知道任务结束了,不管是因为完成还是取消。

这个实验也暴露了取消机制的本质:取消不是「杀死线程」,而是「让线程在下一个检查点自己退出」。所以检查点要足够密,但也不能太密,否则每次循环都读原子变量、发消息,开销会上来。对于每步 10 毫秒的任务,每步检查一次很合适;对于每步只有几微秒的循环,可以每 100 步检查一次。

这次运行的总耗时是 605.954 毫秒,接近「12 次 50 毫秒心跳」的 600 毫秒,多出来的几毫秒是线程调度和消息发送的开销。工作线程每步睡 10 毫秒,100 步本来要一秒多,但取消在第 60 步左右就生效了,所以它没跑完。这个差值正好说明取消是协作式的:不是主线程把工作线程杀掉,而是工作线程在检查点看到标志后自己退出。

进度别发得太勤

新手常把进度当成「每处理一条就发一条消息」。一万条数据就是一万条消息,界面线程光是处理这些消息就忙不过来,最后比任务本身还慢。正确做法是节流:按数量发,比如每 100 条发一次;或者按时间发,比如每 100 毫秒最多发一次。界面需要的不是每一条的真实值,而是「看起来在动」。

还有一种反向问题:发得太少。处理很快的任务,用户还没来得及看到进度就结束了,界面会闪一下。可以在开始和结束各补一条事件,让界面有明确的「开始」和「完成」状态,中间没有进度也不突兀。

消息通道的选择也有讲究。标准库的 channel 是无界的,后台线程发得再快也不会阻塞,但消息会堆在内存里,界面消费不过来时占用会一直涨。改用 sync_channel 并给一个较小的上界,可以让后台线程在界面忙时自然放慢,代价是任务速度受界面影响。桌面工具里,我倾向于有界通道加节流,宁可慢一点,也不要内存不可控。

本机这个实验用的是无界 channel,因为总共只有十几个进度事件,不会堆积。换成十万行导出,每 1000 行发一条也有一百条,仍然可控;真正危险的是「每行都发」加「界面消费慢」,那时无界通道会让内存一路上涨。判断要不要换 sync_channel,看的是生产速度和消费速度的差距,不是消息条数的绝对值。

还要区分消息的重要性。进度只是给人看的,丢几条不影响正确性;结束状态不能丢,它决定界面停在哪个状态。可以给进度用有界通道,满了就跳过这一条;给结束状态用单独的一次性回执,确保一定送到。混在一个通道里,最容易出现「结束消息被一堆进度挤在后面」的情况。

失败与 panic 也要有结局

任务失败时,最常见的错误是「只在成功路径发结束事件」。文件读不到、目录没有权限、磁盘写满,这些错误如果只打在日志里,界面会永远停在「正在导出」。正确做法是把结果包成一个枚举:成功、失败、取消,三种都发一条结束事件,界面按状态显示不同的提示。

enum TaskResult {
    Done { output: String },
    Failed { message: String },
    Cancelled,
}

线程 panic 是另一种容易被忽略的失败。后台线程里一个 unwrap 失败,线程直接结束,join 会返回错误,但如果你没有检查返回值,界面就永远等不到结束事件。至少在 join 处判断一下,把 panic 转成一条失败事件。需要更细的错误信息时,可以在任务外层包一层 catch_unwind,把 panic 内容记下来;但不要用它掩盖所有错误,panic 通常意味着代码有 bug,应该修,而不是吞掉。

取消和失败要区分开。用户主动取消不是错误,界面不应该弹红色警告,也不应该写进错误日志。任务因为权限问题失败才是错误。把两者混在一起,用户会觉得「我点取消,你还骂我」。

Tauri 里的分工

Tauri 的同步命令跑在界面线程上,异步命令跑在异步运行时里。一个实用的分工是:短、快、只读写少量内存的命令保持同步;会碰磁盘、网络、压缩的命令写成 async,并把真正的重活交给阻塞线程池。下面是一个导出命令的骨架,结构和上一组文章保持一致。本机的同步 greet 命令实测往返 7.9 毫秒;异步命令和这里的导出骨架没有单独跑过,这一项仍未验证,所以这段代码只是结构参考,别把它当成已经压测过的实现。

use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use tauri::{AppHandle, Emitter, State};

struct ExportState {
    cancel: Arc<AtomicBool>,
}

#[tauri::command]
async fn export_csv(
    path: String,
    app: AppHandle,
    state: State<'_, ExportState>,
) -> Result<usize, String> {
    let cancel = Arc::clone(&state.cancel);
    cancel.store(false, Ordering::Relaxed);

    tauri::async_runtime::spawn_blocking(move || {
        let mut written = 0usize;
        for row in 0..100_000 {
            if cancel.load(Ordering::Relaxed) {
                return Err("已取消".to_string());
            }
            // 写一行,按时间或数量节流上报
            written += 1;
            if written % 1000 == 0 {
                let _ = app.emit("export/progress", written);
            }
        }
        Ok(written)
    })
    .await
    .map_err(|err| format!("任务异常: {}", err))?
}

#[tauri::command]
fn cancel_export(state: State<'_, ExportState>) {
    state.cancel.store(true, Ordering::Relaxed);
}

这里有两个细节值得注意。State 的生命周期参数在异步命令里要写出来,否则编译器会报错;spawn_blocking 返回的是一个 JoinHandle,await 之后还要再处理一层 Result,因为任务本身可能 panic。把这两层都处理掉,界面才不会卡在中间状态。

这两个细节在本机没有真实跑过,因为异步导出命令没有单独执行。能确认的相邻事实是:同步 greet 往返 7.9 毫秒,说明命令通道本身很快;一旦把耗时循环塞进同步命令,界面就会按循环的时长卡住。异步命令的价值不是「让命令变快」,而是「让界面线程不被占住」,这两件事经常被混为一谈。

如果任务里有大量 IO 等待而不是 CPU 计算,用异步 IO 更合适;如果是压缩、加密、解析这种持续吃 CPU 的活,阻塞线程池才是对的。判断标准是:任务在等外部资源,还是在自己算。等外部资源用异步,自己算用线程。

从需求到跑起来:导出十万行

把需求定成「导出十万行 CSV,显示进度,可取消,关闭窗口时安全退出」,完整顺序如下。

长任务的生命周期
点击开始,禁用按钮并创建取消标志
后台线程读取数据并分批写入临时文件
按节流频率上报进度
完成、失败或取消都发结束事件
关闭临时文件,原子替换目标文件

第一步的验收标准是:重复点击不会再启动第二个任务。第二步的验收标准是:写入的是临时文件,失败不会破坏已有文件。第三步的验收标准是:进度事件不超过每秒十次,界面不因为消息太多而卡。第四步的验收标准是三种结局都有,且界面能区分。第五步的验收标准是:取消时临时文件被删除,完成时才替换。

关闭窗口是这套流程里最容易漏的场景。用户点右上角的叉,进程不应立刻被系统杀掉,否则临时文件可能残留,目标文件可能写到一半。比较稳的做法是拦截关闭事件,设置取消标志,等待任务在超时时间内结束,再真正退出;超时后也要清理临时文件。不同平台对「关闭窗口」的默认行为不一样,macOS 常常只是隐藏窗口,进程继续运行,这一点要单独验证。

Tauri 的启动数据可以作为一个参照:窗口从启动到可交互是 67 到 68 毫秒,工作集 25.1 MB。这说明框架本身的启动开销不大;用户感觉「关窗很慢」,通常是你自己的退出清理在等线程或等 IO,而不是 Tauri 在拖。把退出路径上的每一步打上时间戳,和启动基线放在一起看,问题会清楚很多。

出了问题先看哪里

现象真实原因第一步查什么
点开始后窗口变「未响应」任务跑在界面线程上看命令是否同步;把重活移出界面线程
点取消后进度还在走取消标志没传到循环,或检查点太少在循环里打印取消标志;检查检查点间隔
进度条卡在 99%只发了进度,没发结束事件在成功、失败、取消三个出口都补事件
任务失败但界面一直显示进行中错误被吞掉,没有回传检查 join 返回值与错误分支
关窗后进程还在后台线程还在跑,主线程没有等待或取消任务管理器看线程;检查关闭事件处理
长时间导出后内存一直涨进度消息无界堆积,或数据全读进内存换成有界通道;改成分批读取
界面收到乱序或重复进度多个任务共用同一个事件名给任务加编号;结束旧任务再开新的
取消后任务停了,但目标文件是空的直接写目标文件,取消时文件已被截断改成先写临时文件,成功后再原子替换

边界与代价

线程不是越多越好。每个线程有栈空间和调度开销,开一百个线程去处理一百个文件,通常比一个线程顺序处理更慢。桌面工具的合理做法是:一个任务一个后台线程,或者固定大小的线程池;需要并行时按 CPU 核心数控制上限。Rust 的 std::thread 足够用,不必为了「异步」而引入整套运行时。

取消也有代价。原子标志只能做到「协作式取消」,任务不检查,就永远停不下来。文件读写、网络请求这类阻塞调用,可能要等超时才能返回。更彻底的取消需要把任务拆成可中断的段,或者使用支持取消的运行时。别向用户承诺「点了立刻停」,实际能做到的是「在下一个安全点停」。

还有一个和取消相关的实践:把「已经取消」当成正常返回值,而不是错误。本机实验里的 999 结束标记就是这个意思,它让界面知道任务结束了,但不区分完成还是取消。真实实现里可以再带一个状态字段,避免前端靠猜。状态字段不增加多少复杂度,却能省掉大量「为什么进度条停在 50%」的排查。

优先级和 CPU 占用也值得注意。后台任务把八个核心跑满,用户切到别的程序会觉得整机变卡。可以给线程设置较低的优先级,或者在每批之间主动让出一次。桌面程序的第一目标是「不打扰用户」,不是「跑分最高」。

当天能验证的练习

  1. 把 worker_cancel.rs 的取消检查从「每步一次」改成「每 20 步一次」,测量取消延迟的变化。
  2. 把进度上报改成每步都发,观察接收端处理消息的耗时,感受节流的必要性。
  3. 在后台任务里制造一次 panic,观察主线程是否能收到失败信号,补上处理。
  4. 把任务改成写临时文件、成功后再重命名,验证取消时目标文件没有被破坏。
  5. 模拟关闭窗口:设置取消标志后等待任务结束,记录从点击到进程真正退出的时间。

记录数字时,建议固定两段:从点击取消到 join 返回的毫秒数,以及从点击关闭到进程真正退出的毫秒数。前者反映检查点密度,后者反映清理逻辑;本机实验里 600 毫秒发出取消、605.954 毫秒任务结束,差值只有几毫秒,就是因为检查点足够密。换到你自己的任务上,这个差值会直接告诉用户「点了取消之后还要等多久」。

任务能跑、能停、能报错之后,就要面对「发出去以后怎么升级」的问题。新版本装不上、装上了打不开、打开后配置丢了,这些都比开发阶段的问题更难查。下一篇讲自动更新、签名与回滚,从版本号比较开始,一直做到失败后能退回旧版本。