一个典型的现场:设置面板里刚把主题切成深色,界面也确实变了,但过一会儿重新打开面板,下拉框又回到浅色。查日志发现保存是成功的,读取也返回成功,可读出来的值就是旧的。再比如导出任务,进度条走到 99% 就停住,用户以为卡死,其实是最后一条「完成」事件根本没发出来。
这类问题的共同点,是「界面看到的」和「Rust 里真实的」对不上。桌面应用的通信不像网页请求那样天然串行:命令可以并发执行,事件可以从任何线程发出,共享状态被多个入口同时读写。只要有一处没想清楚顺序,就会出现看起来毫无道理的旧值、丢事件、重复触发。这篇就把 invoke、事件和共享状态这三件事拆开,用一个能跑的并发实验说明顺序是怎么乱的,再给出能落地的协议写法。
invoke 到底是什么
前端调用 invoke("命令名", 参数),本质是发一条消息给 Rust 进程,等待一个结果,然后兑现成一个 Promise。它有三个容易误解的地方。
第一,它是异步的。前端代码里不写 await,后面的逻辑就会先于结果执行。第二,命令不是天然并发的,也不是天然串行的,取决于命令怎么写。同步命令默认在界面线程上执行,写个耗时循环进去,窗口就会失去响应;写成 async 命令,框架会把它放到异步运行时里,不阻塞界面线程,但也不代表它能自动并行,真正耗 CPU 的活还是要显式丢到阻塞线程池。第三,每次调用都是独立的一次请求,框架不保证两个请求的处理先后,除非你自己在 Rust 侧串行化。
先把一个真实数字放在这里:本机 Tauri 应用打开 withGlobalTauri 后,前端调用 window.__TAURI__.core.invoke('greet',{name:'科设'}),从发出到 Promise 兑现,往返 7.9 毫秒。这条命令只做字符串拼接,所以 7.9 毫秒基本就是「序列化参数、跨进程消息、执行、序列化结果、回到前端」的固定成本。它说明 IPC 通道本身不是瓶颈;但它不是所有命令的基准,命令里多读一个文件,时间就会跟着文件走。
async 命令并配合 spawn_blocking,或者把任务交给独立线程。共享状态:锁住什么,锁多久
Tauri 用 State 把一份全局数据注入到命令里,通常配一个 Mutex。写法本身不难,难的是锁的范围。下面这段是常见但危险的顺序:先拿锁,再做一个耗时操作,最后写值。这段时间里,其他命令全在等锁,界面上的读取请求就会排队,看起来像卡住。
// 不推荐:锁跨越了耗时操作
let mut guard = state.settings.lock().unwrap();
let parsed = parse_big_file(&guard.path); // 几十毫秒甚至更久
guard.last_result = parsed;
更稳的做法是先把需要的数据复制出来,释放锁,再做耗时计算,最后重新拿锁写回。如果确实需要在异步任务里跨 await 持锁,就要用异步版本的锁,否则会阻塞整个运行时。判断标准是:锁的持有时间里不能有文件读写、网络请求、循环等待。
// 推荐:锁只包住数据访问
let path = {
let guard = state.settings.lock().unwrap();
guard.path.clone()
};
let parsed = parse_big_file(&path); // 锁已释放
{
let mut guard = state.settings.lock().unwrap();
guard.last_result = parsed;
}
还有一个隐蔽问题:读和写用不同的入口。比如设置保存写进了 Rust 的 State,但界面显示读的是前端自己的变量。两边都「成功」,却永远不同步。状态只能有一个事实来源,要么以 Rust 为准,每次变更后通知前端;要么以前端为准,Rust 只负责持久化。混着用,迟早对不上。
Rust 在编译期会帮你挡掉一部分并发错误,但挡不住逻辑错误。共享状态通常写成 Arc<Mutex<T>>,闭包跨线程移动时要满足 Send,这些约束会逼着你想清楚数据归谁所有。可编译器管不了「先读后写」的时序,也管不了锁的粒度。另外,标准库的 Mutex 在持锁线程 panic 后会进入中毒状态,之后每次 lock() 都返回错误;用 unwrap() 会让第二个线程也跟着崩。生产代码里要决定是恢复数据继续用,还是把这次操作整体判失败。
顺序为什么会乱:一个能跑的实验
下面这段程序模拟三个并发命令:设置主题、读取主题、设置字号。三个任务在不同线程里执行,耗时不同,结果通过通道回到界面侧。完整可编译,只用标准库:
use std::collections::HashMap;
use std::sync::mpsc::channel;
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::{Duration, Instant};
fn main() {
let state = Arc::new(Mutex::new(HashMap::<String, String>::new()));
let (tx, rx) = channel::<(u32, String)>();
let start = Instant::now();
let mut handles = Vec::new();
// (id, key, value, 处理耗时):value 为空表示读取
let jobs = [
(1u32, "theme", "dark", 40u64),
(2, "theme", "", 5),
(3, "font", "14", 25),
];
for (id, key, value, delay) in jobs {
let st = Arc::clone(&state);
let tx = tx.clone();
handles.push(thread::spawn(move || {
thread::sleep(Duration::from_millis(delay));
let data = {
let mut map = st.lock().unwrap();
if value.is_empty() {
map.get(key).cloned().unwrap_or_else(|| "<none>".to_string())
} else {
map.insert(key.to_string(), value.to_string());
format!("{}={}", key, value)
}
};
tx.send((id, data)).unwrap();
}));
}
drop(tx);
for (id, data) in rx {
println!(
"[ui] {:>4}ms recv id={} data={}",
start.elapsed().as_millis(),
id,
data
);
}
for handle in handles {
handle.join().unwrap();
}
println!("[state] {:?}", *state.lock().unwrap());
}
rustc -O ipc_parallel.rs
.\ipc_parallel.exe
[ui] 28ms recv id=2 data=<none>
[ui] 51ms recv id=3 data=font=14
[ui] 62ms recv id=1 data=theme=dark
[state] {"font": "14", "theme": "dark"}
输出把问题暴露得很清楚:读取请求 id=2 只用了 5 毫秒就返回,但此时设置请求 id=1 还在睡 40 毫秒,所以读到的是 <none>。用户看到的现象就是「我刚保存了,怎么读出来是空的」。而最终状态里 theme 确实是 dark,说明数据没丢,只是读的时机不对。上面的毫秒数来自一次真实运行,每次执行会有几毫秒浮动,值得看的是返回顺序而不是具体数值。
把同样的三条命令交给一个单线程工作者串行处理,行为就变成另一头:读请求必须排在写请求后面,不会读到旧值,但总耗时是三者之和,慢命令会拖住后面的所有请求。这两种模型没有绝对好坏:需要强顺序就用单线程队列,需要吞吐就用并发加请求标识。关键是你要知道自己在用哪一种。
把本机的 Tauri 数字和这个实验放在一起,能看出两件事的分界。Tauri 的 7.9 毫秒是一条真实命令的往返,包含完整的序列化和进程间传递;实验里的 5、25、40 毫秒是人为设定的处理耗时,用来放大顺序问题。前者告诉你「通道有多快」,后者告诉你「处理有快有慢时,返回顺序会怎样」。真实系统里两者叠加:即使通道只要几毫秒,一个慢命令仍然会排在快命令后面返回。
一套够用的消息协议
不管用哪种模型,跨进程或跨线程的消息都建议带上三个字段:请求编号、成功标志、数据或错误。前端收到响应时按编号匹配,而不是假设「下一条就是刚才那条」。事件推送同理,最好带一个类型字段,避免监听回调里写一堆条件判断。
{ "id": 7, "ok": true, "data": { "theme": "dark" } }
{ "id": 8, "ok": false, "error": "目录不存在" }
{ "event": "scan/progress", "id": 9, "done": 41, "total": 120 }
在 Tauri 里,命令本身已经帮你做了请求与响应的配对,返回值就是结果,抛错就是错误,所以编号主要是给事件用的。一次长任务建议约定三个事件:开始、进度、结束。结束事件必须无论成功失败都发,并且带上最终状态。进度条卡在 99%,十有八九是只发了进度没发结束,前端一直在等最后一条。
命令通道和事件通道解决的不是同一个问题,混用是很多「值不同步」的根源。命令是请求-响应模型:一次调用对应一个结果,前端能 await,能拿到返回值或错误,框架帮你配对;事件是单向广播:Rust 发出去就不管了,没有返回值,也不确认前端是否处理。上面的 report 函数用 emit,前端用 listen,两者之间没有请求编号,所以事件只能表达「发生了什么」,不能表达「这次操作成功没有」。
这也决定了两者的顺序关系:命令的 Promise 兑现和事件的到达是两条独立路径,不能假设「命令返回时事件已经处理完」。如果界面既等命令结果、又等事件刷新,就可能出现命令已成功、界面还没收到事件的中间态。稳妥的做法是二选一:要么让命令的返回值带上最终状态,事件只负责增量通知;要么命令只表示「已受理」,最终状态完全由事件推进。两种都行,混着用最容易对不上。
协议一旦发出去就很难改,所以字段要留余地。比如错误不要只给一个字符串,至少分成代码和可读消息两部分,这样前端能做分支处理,而不是靠匹配中文。数据部分尽量用对象而不是裸数组,将来加字段不会破坏旧代码。还有一个实践:事件名带模块前缀,比如 scan/progress、export/done,避免不同功能的事件混在一个命名空间里,排查时也能一眼看出是谁发的。
Rust 侧发事件的写法大致如下,注意 Tauri 2 需要引入 Emitter:
use tauri::{AppHandle, Emitter};
#[derive(Clone, serde::Serialize)]
struct Progress {
done: usize,
total: usize,
}
fn report(app: &AppHandle, done: usize, total: usize) {
let _ = app.emit("scan/progress", Progress { done, total });
}
前端监听时,务必保存返回的取消函数,并在组件卸载或页面关闭时调用。重复注册监听是「同一个事件触发两次」的常见原因,尤其是在开发模式下热更新频繁的时候。
从上面的代码还能看出一个细节:listen 是异步注册的,返回的 unlisten 必须等 await 完成才拿得到。如果在 await 之前页面就卸载了,这个监听会留在原地。把注册和取消放在同一个生命周期里,注册完立刻保存句柄,销毁时无条件调用,能避免大部分重复触发。
import { listen } from "@tauri-apps/api/event";
const unlisten = await listen("scan/progress", (event) => {
const { done, total } = event.payload;
bar.style.width = `${Math.round((done / total) * 100)}%`;
});
// 页面或组件销毁时
window.addEventListener("beforeunload", () => {
unlisten();
});
从需求到跑起来:设置面板走查
把上面这些拼成一个可用的设置面板,顺序是这样的。
第一步的验收标准是:读取返回的值和磁盘上的值一致,且不依赖界面缓存。第二步的验收标准是:提交期间按钮禁用,重复点击不会发出两次请求。第三步的验收标准是:写入失败时状态回滚,不能出现「磁盘没写成功但内存已改」的情况。第四步的验收标准是:事件里带上新值,而不是让界面再发一次读取。第五步的验收标准是:刷新只改相关控件,不重建整个页面。
这里有个容易忽略的取舍:每次变更都发完整状态,还是只发变化的部分?完整状态简单,前端不用合并逻辑,但状态大了会浪费序列化时间;只发变化省流量,但前端要维护合并规则,漏一个字段就不一致。桌面应用的数据量通常不大,建议先发完整状态,等真的遇到性能问题再优化。
设置面板还有一个高频坑:拖动滑块或连续输入时,每一次小变化都触发保存。用户拖一下音量,可能发出几十次写入。解决办法是在前端做防抖,等用户停手几百毫秒再提交;或者在 Rust 侧做合并,把短时间内的多次写入压成一次。前者实现简单,后者更可靠,两者可以同时用。
回到设置面板,命令和事件的分工可以写得很具体:保存走命令,因为需要知道成功还是失败;刷新走事件,因为可能不止一个窗口需要更新。保存命令的返回值里带上写入后的完整设置,界面收到返回值就先更新一次,事件到达时再更新一次,两次内容相同,重复但安全。这样即使事件晚到或丢失,界面也不会停在旧值上。
出了问题先看哪里
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 刚保存的值读出来是旧的 | 读请求先于写请求完成,或读的是前端缓存 | 给请求打编号,打印返回顺序与时间戳 |
| 两条命令互相覆盖 | 共享状态没加锁,或锁的范围只包住了一半 | 检查 Mutex 是否覆盖完整读改写过程 |
| 进度条停在 99% | 只发了进度事件,没发结束事件 | 在任务出口补一条 done 或 error 事件 |
| 点一下界面卡两秒 | 同步命令在界面线程里做重活 | 看命令是否 async,重活是否进了阻塞线程池 |
| 同一个事件触发两次 | 监听重复注册,卸载时没取消 | 保存 unlisten 并在销毁时调用 |
| 传大列表时界面明显变慢 | 一次序列化过大的 JSON | 分页传输,或只传路径让 Rust 按需读 |
| 关窗后后台还在写文件 | 后台任务没有取消机制 | 检查是否有取消标志,退出前是否 join |
边界与代价
IPC 不是免费的。每次调用都有序列化和线程切换的开销,传一个大对象比传一个路径慢得多。桌面应用里常见的错误是把整个文件内容读成字符串再传给前端,前端只是要显示一个预览。更好的做法是传路径或句柄,让需要的时候再取,或者分页取。
7.9 毫秒这个数字还说明另一件事:小消息的 IPC 成本很低,真正贵的是消息体积。一个只带路径的命令和一个带十兆 Base64 的命令,通道开销可能差出几个数量级。判断要不要分页,不用猜,把 payload 大小打进日志,连续几次超过几百 KB 就该拆。桌面应用在同一台机器上通信,带宽不是问题,序列化和内存复制才是。
状态管理也没有一劳永逸的方案。全局 Mutex 简单,但容易变成瓶颈;拆成多个锁能提高并发,但会引入锁顺序问题,弄不好就死锁。我的建议是先用一个锁把功能做对,测量确实卡了再拆。桌面工具的用户量通常不大,正确性比极限吞吐重要得多。
调试通信问题时,日志要打在边界上:命令进入时打一条,拿到结果时打一条,事件发出时打一条,事件收到时打一条。四条日志带同一个请求编号,就能还原整条链路。只在出错的地方打日志,往往看不出「到底是没发、发晚了、还是发错了」。
当天能验证的练习
- 把
ipc_parallel.rs里读请求的延迟从 5 毫秒改成 60 毫秒,观察它读到的值是否变成新值,解释原因。 - 把三个任务改成单线程串行执行,记录总耗时,和并发版本对比。
- 给消息协议加一个
version字段,模拟前端收到旧版本消息时的兼容处理。 - 写一个会失败的
set命令(比如值为空就报错),确认前端能拿到错误字符串并显示。 - 在你的界面里注册两次同一个事件监听,观察重复触发,然后加上取消逻辑修掉它。
- 在打开
withGlobalTauri的工程里调一次invoke('greet'),用performance.now()记录往返毫秒数,再和一个故意休眠 50 毫秒的命令对比。
通信链路稳了以后,界面不一定非要用 WebView。有些场景下,网页外壳本身的启动开销和资源占用就是不能接受,这时候要换到原生窗口路线。下一篇讲 winit 与自绘界面:事件循环长什么样、为什么每一帧都要自己画、以及它和 Tauri 的模型差在哪。