导出按钮点下去,窗口标题栏立刻变成「未响应」,鼠标移过去是转圈,用户只能等,或者强行结束进程。改成后台线程以后,界面不卡了,但新的抱怨来了:点了取消,进度还在走;关掉窗口,任务管理器里进程还在;任务明明失败了,界面却一直停在「正在导出」。
这三个现象分别对应三件没做好的事:任务没有真正离开界面线程;取消只是一个按钮,没有传达到正在干活的循环;任务的结束状态没有可靠地回到界面。桌面程序的长任务不是「开个线程」就完事,它是一条完整的生命周期:启动、报进度、可取消、成功或失败、清理资源。这篇用一个能跑的目录扫描实验把这套生命周期走一遍,再把 Tauri 里的分工讲清楚。
为什么界面会卡
界面线程(也叫主线程、UI 线程)的工作是处理事件:鼠标、键盘、重绘、窗口消息。它必须快速返回,才能继续处理下一个事件。你在它上面跑一个两秒的循环,这两秒里所有事件都排队,系统就会认为程序失去响应,标题栏变灰,用户点击没有反馈。
所以规则只有一条:耗时操作不能占着界面线程。判断「耗时」的标准不是代码行数,而是有没有等待:读大文件、遍历几万个目录、网络请求、压缩、加密,都属于这一类。哪怕只有两百毫秒,只要用户在这段时间里连续点击,体验就会变差。
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%」的排查。
当天能验证的练习
- 把
worker_cancel.rs的取消检查从「每步一次」改成「每 20 步一次」,测量取消延迟的变化。 - 把进度上报改成每步都发,观察接收端处理消息的耗时,感受节流的必要性。
- 在后台任务里制造一次 panic,观察主线程是否能收到失败信号,补上处理。
- 把任务改成写临时文件、成功后再重命名,验证取消时目标文件没有被破坏。
- 模拟关闭窗口:设置取消标志后等待任务结束,记录从点击到进程真正退出的时间。
记录数字时,建议固定两段:从点击取消到 join 返回的毫秒数,以及从点击关闭到进程真正退出的毫秒数。前者反映检查点密度,后者反映清理逻辑;本机实验里 600 毫秒发出取消、605.954 毫秒任务结束,差值只有几毫秒,就是因为检查点足够密。换到你自己的任务上,这个差值会直接告诉用户「点了取消之后还要等多久」。
任务能跑、能停、能报错之后,就要面对「发出去以后怎么升级」的问题。新版本装不上、装上了打不开、打开后配置丢了,这些都比开发阶段的问题更难查。下一篇讲自动更新、签名与回滚,从版本号比较开始,一直做到失败后能退回旧版本。