一个典型的现场:设置面板里刚把主题切成深色,界面也确实变了,但过一会儿重新打开面板,下拉框又回到浅色。查日志发现保存是成功的,读取也返回成功,可读出来的值就是旧的。再比如导出任务,进度条走到 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 通道本身不是瓶颈;但它不是所有命令的基准,命令里多读一个文件,时间就会跟着文件走。

同步命令里做重活,是 Tauri 应用「点一下卡两秒」的最常见原因。判断方法很简单:在命令开头和结尾各打一条带时间戳的日志,如果两条日志之间隔了很久,而界面在这段时间里不动,就是这个问题。改成 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 校验后写入状态与磁盘
发送变更事件
界面按事件刷新显示

第一步的验收标准是:读取返回的值和磁盘上的值一致,且不依赖界面缓存。第二步的验收标准是:提交期间按钮禁用,重复点击不会发出两次请求。第三步的验收标准是:写入失败时状态回滚,不能出现「磁盘没写成功但内存已改」的情况。第四步的验收标准是:事件里带上新值,而不是让界面再发一次读取。第五步的验收标准是:刷新只改相关控件,不重建整个页面。

这里有个容易忽略的取舍:每次变更都发完整状态,还是只发变化的部分?完整状态简单,前端不用合并逻辑,但状态大了会浪费序列化时间;只发变化省流量,但前端要维护合并规则,漏一个字段就不一致。桌面应用的数据量通常不大,建议先发完整状态,等真的遇到性能问题再优化。

设置面板还有一个高频坑:拖动滑块或连续输入时,每一次小变化都触发保存。用户拖一下音量,可能发出几十次写入。解决办法是在前端做防抖,等用户停手几百毫秒再提交;或者在 Rust 侧做合并,把短时间内的多次写入压成一次。前者实现简单,后者更可靠,两者可以同时用。

回到设置面板,命令和事件的分工可以写得很具体:保存走命令,因为需要知道成功还是失败;刷新走事件,因为可能不止一个窗口需要更新。保存命令的返回值里带上写入后的完整设置,界面收到返回值就先更新一次,事件到达时再更新一次,两次内容相同,重复但安全。这样即使事件晚到或丢失,界面也不会停在旧值上。

出了问题先看哪里

现象真实原因第一步查什么
刚保存的值读出来是旧的读请求先于写请求完成,或读的是前端缓存给请求打编号,打印返回顺序与时间戳
两条命令互相覆盖共享状态没加锁,或锁的范围只包住了一半检查 Mutex 是否覆盖完整读改写过程
进度条停在 99%只发了进度事件,没发结束事件在任务出口补一条 done 或 error 事件
点一下界面卡两秒同步命令在界面线程里做重活看命令是否 async,重活是否进了阻塞线程池
同一个事件触发两次监听重复注册,卸载时没取消保存 unlisten 并在销毁时调用
传大列表时界面明显变慢一次序列化过大的 JSON分页传输,或只传路径让 Rust 按需读
关窗后后台还在写文件后台任务没有取消机制检查是否有取消标志,退出前是否 join

边界与代价

IPC 不是免费的。每次调用都有序列化和线程切换的开销,传一个大对象比传一个路径慢得多。桌面应用里常见的错误是把整个文件内容读成字符串再传给前端,前端只是要显示一个预览。更好的做法是传路径或句柄,让需要的时候再取,或者分页取。

7.9 毫秒这个数字还说明另一件事:小消息的 IPC 成本很低,真正贵的是消息体积。一个只带路径的命令和一个带十兆 Base64 的命令,通道开销可能差出几个数量级。判断要不要分页,不用猜,把 payload 大小打进日志,连续几次超过几百 KB 就该拆。桌面应用在同一台机器上通信,带宽不是问题,序列化和内存复制才是。

状态管理也没有一劳永逸的方案。全局 Mutex 简单,但容易变成瓶颈;拆成多个锁能提高并发,但会引入锁顺序问题,弄不好就死锁。我的建议是先用一个锁把功能做对,测量确实卡了再拆。桌面工具的用户量通常不大,正确性比极限吞吐重要得多。

调试通信问题时,日志要打在边界上:命令进入时打一条,拿到结果时打一条,事件发出时打一条,事件收到时打一条。四条日志带同一个请求编号,就能还原整条链路。只在出错的地方打日志,往往看不出「到底是没发、发晚了、还是发错了」。

跨平台差异在 IPC 这一层不明显,但在事件和窗口上很明显:同一个应用开多个窗口时,事件要指定发往哪个窗口,否则所有窗口都会收到;macOS 的窗口关闭常常只是隐藏,进程还活着,后台任务不会自动停。写「关闭即退出」的逻辑时,要按平台分别验证。

当天能验证的练习

  1. 把 ipc_parallel.rs 里读请求的延迟从 5 毫秒改成 60 毫秒,观察它读到的值是否变成新值,解释原因。
  2. 把三个任务改成单线程串行执行,记录总耗时,和并发版本对比。
  3. 给消息协议加一个 version 字段,模拟前端收到旧版本消息时的兼容处理。
  4. 写一个会失败的 set 命令(比如值为空就报错),确认前端能拿到错误字符串并显示。
  5. 在你的界面里注册两次同一个事件监听,观察重复触发,然后加上取消逻辑修掉它。
  6. 在打开 withGlobalTauri 的工程里调一次 invoke('greet'),用 performance.now() 记录往返毫秒数,再和一个故意休眠 50 毫秒的命令对比。

通信链路稳了以后,界面不一定非要用 WebView。有些场景下,网页外壳本身的启动开销和资源占用就是不能接受,这时候要换到原生窗口路线。下一篇讲 winit 与自绘界面:事件循环长什么样、为什么每一帧都要自己画、以及它和 Tauri 的模型差在哪。