一个备份脚本每天凌晨跑,调用 rsync 同步目录,再打印「备份完成」。某天磁盘满了,rsync 以非零退出码结束,脚本照样打印「备份完成」,第二天要用的时候才发现数据是半截的。问题不在 rsync,在脚本只读了输出、没看退出码。

进程间的关系比函数调用复杂得多:子进程有自己的地址空间、自己的退出状态、自己的标准输入输出;它可能永远不退出,可能写满管道把父进程卡死,可能被杀掉后留下一个没人回收的句柄。这一篇把 std::process 的能力边界讲清楚,重点是「什么时候该用哪个收尾方式」和「它不替你做什么」。示例在 Windows 上实际编译运行,涉及信号的段落会明确标注未实测。

三种收尾方式,对应三种需求

Command 提供三种常见组合,选错了就会出现「卡死」或「拿不到退出码」:

status

只关心成功失败,不读输出。会等子进程结束,返回 ExitStatus。适合「执行一个动作,失败就报错」。

output

要拿标准输出和标准错误。内部会读取两个管道直到结束,避免管道写满,返回 Output。适合短命令、输出量可控的场景。

第三种是 spawn,拿到 Child 后自己控制:可以写 stdin、逐行读 stdout、轮询 try_wait、超时后 kill。灵活,但责任也全在你身上——不调用 wait 就可能留下资源,不读管道就可能死锁。

还有一种选择是「根本不启动外部进程」。很多需求最初写成调用命令行工具,后来发现同一件事可以用库做:解析 JSON、压缩文件、发 HTTP 请求,都有成熟的 Rust 库。外部进程的代价是版本不受控、错误信息难解析、跨平台行为不一致、还多了一层进程开销。只有当你需要复用系统已有的能力(比如 git、ffmpeg、数据库自带的备份工具),或者那个工具的语义复杂到不值得重写,才值得起子进程。

默认情况下,子进程的 stdin/stdout/stderr 会继承父进程。这意味着子进程可以直接写终端,也可以抢走父进程的输入。命令行工具里这通常是想要的;但如果你在 TUI 或者已经接管了 stdin 的程序里起子进程,子进程的提示会打乱界面,甚至让两边同时等输入。要隔离就显式设置 Stdio::piped() 或 Stdio::null(),不要依赖「它应该不会读 stdin」这种假设。

实测三种基本用法:

status    => code=Some(3) success=false
output    => status=Some(0) stdout="hello-from-child"

status().code() 返回 Option<i32>,因为「被信号杀死」的进程没有正常的退出码。Windows 上被 TerminateProcess 结束的进程通常给一个非零码,Unix 上则是 None,具体含义要结合信号看。这个差异决定了「成功判断」不能只写 code() == Some(0),更稳的是 status.success()。

退出码 0 表示成功、非 0 表示失败,这是跨平台的约定,但具体数字的含义由程序自己定义。写自动化流程时,不要把「非 0」当成一种错误,最好按数字分支:1 是普通失败、2 是参数错误、127 是命令找不到(Unix shell 约定),这些约定能省掉很多猜测。

管道:不读就会卡死

管道是有限长度的内核缓冲区。子进程往 stdout 写,父进程不读,写满之后子进程就阻塞在 write,永远不退出;父进程如果在 wait,就永远等下去。这是一个经典死锁,跟语言无关。

output() 帮你避开了它,因为它内部会持续读。用 spawn 加 Stdio::piped() 就必须自己读。正确顺序通常是:先读 stdout/stderr 到结束,再 wait;或者用单独的线程读,主线程 wait。不要反过来「先 wait 再读」,那正是死锁的写法。

实测用 findstr 从 stdin 读两行再回显,父进程写入后必须关闭 stdin 才能让子进程看到 EOF:

stdin     => "alpha\nbeta"

关闭的方式是 drop(child.stdin.take()) 或者让 child.stdin 离开作用域。只 flush 不关闭,子进程会一直等下一行,因为它不知道你写完了。这个细节在交互式工具里经常出问题:界面看起来「发出去了」,对端却一直挂着。

逐行读:长任务的正确姿势

编译、测试、部署这类长任务,输出是持续产生的。用 output() 会等全部结束才拿到内容,用户几分钟看不到任何反馈;正确做法是 spawn,拿 stdout.take(),用 BufReader 逐行读,边读边打印。实测:

stream    => "line-1"
stream    => "line-2"
stream    => "line-3"
stream    => code=Some(0)

注意 take() 会把 Option<ChildStdout> 拿走,之后 child 仍然可以 wait。wait 必须调用,否则子进程结束后会留下一个「僵尸」条目(Unix)或未关闭的句柄(Windows)。Rust 的 Child 在析构时不会自动 wait,这一点和很多语言不一样,别指望 GC 或 Drop 帮你收尾。

如果 stdout 和 stderr 都要读,就别在同一个线程里顺序读:先读完 stdout 再读 stderr,可能因为 stderr 写满而卡住。给每个流开一个线程,或者合并成一路(stderr(Stdio::piped()) 后分别处理)。这也是「子进程输出很多」时最常见的卡死原因。

output() 把所有输出收进内存再返回,命令输出几百 MB 时,父进程也会跟着吃几百 MB。这类场景只能用 spawn 加流式读取,边读边处理或落盘。判断标准是「输出量是否可能超过内存预算」,而不是「命令看起来短不短」——git log 在一个大仓库里也能输出几百 MB。

超时:标准库没有现成的

Command 没有 timeout 参数。要实现「最多等 5 秒,超时就杀掉」,只能自己轮询 try_wait:

let mut child = Command::new("slow-tool").spawn()?;
let deadline = Instant::now() + Duration::from_secs(5);
loop {
    if let Some(status) = child.try_wait()? {
        break;
    }
    if Instant::now() >= deadline {
        child.kill()?;
        let status = child.wait()?;
        break;
    }
    thread::sleep(Duration::from_millis(50));
}

kill 之后仍然要 wait:kill 只是发信号或调用终止接口,不等于子进程已经被回收。wait 才是回收点。实测先 kill 再 wait:

killed    => code=Some(1) success=false

Windows 上被杀的子进程退出码是 1,Unix 上 code() 可能是 None,要用 std::os::unix::process::ExitStatusExt::signal() 拿信号编号。这段在本机 Windows 上无法运行,标注未实测。跨平台代码应该把「超时被杀」单独标记成一种结果,而不是去猜退出码的含义。

轮询间隔 50 毫秒是经验值:太短浪费 CPU,太长会让超时判定不准。更精细的做法是用平台的事件等待接口,但那已经超出标准库范围。对普通运维工具,轮询足够。

还有一个 API 细节:wait_with_output 会消费 Child,内部关闭 stdin、读完 stdout/stderr,再等待结束,返回 Output。它方便,但只能调用一次,之后不能再拿 Child 做别的事。如果既要逐行输出又要最终结果,就得自己读流、自己 wait,不能用 wait_with_output。选 API 前先想清楚「我需要在运行过程中看到输出吗」,需要就别用一次性收尾的那个。

环境、目录与参数:别经过 shell

Command::new("prog") 默认直接启动可执行文件,不经过 shell,这是安全的默认值。很多人为了图方便写成 Command::new("sh").arg("-c").arg(format!("ls {}", user_input)),用户输入里一个分号就能注入额外命令。要执行外部程序,直接把参数传给 arg/args,让操作系统处理分隔,不要自己拼字符串。

env 设置或清除环境变量,env_clear 清空继承的环境,current_dir 设置工作目录。后者经常被忽略:子进程的相对路径是相对它的工作目录,不是相对父进程的当前目录。日志里只写「文件不存在」而不写工作目录,排查时会绕很大圈。PATH 也要注意:父进程能跑的程序,子进程不一定能找到,因为环境可能被清理过。

Windows 上还有 creation_flags 可以控制窗口、进程组等行为,属于平台特有 API,用 #[cfg(windows)] 包起来。Unix 上有 CommandExt 的 uid/gid、pre_exec,可以在 fork 后 exec 前做设置,但 pre_exec 里只能做异步信号安全的操作,写日志、分配内存都可能出问题。这些本机没有实测,知道有这些口子即可。

Windows 上还有一个隐蔽的坑:如果你用 cmd /C 执行带空格的路径,引号规则和 Unix shell 完全不同,稍微复杂一点的参数就会被拆错。能直接启动可执行文件就不要经过 cmd。另外 Windows 查找可执行文件时会按 PATHEXT 尝试补 .exe、.bat 等后缀,而 Unix 要求文件名精确匹配;同一个 Command::new("tool"),在两个平台找到的可能不是同一个文件。部署文档里最好把绝对路径写清楚,别让「找得到」变成运气。

资源限制也是标准库不给的。Unix 上可以用 setrlimit 限制子进程的内存、CPU 时间、打开文件数;Windows 上要用 Job Object 设置进程组的内存与 CPU 上限。没有这些限制,一个写错的外部命令可能吃光整台机器的内存,把父进程一起拖死。这段本机没有实测,但它是「调用不可信程序」时必须考虑的一层。

信号与 Ctrl-C:标准库故意没给

Rust 标准库没有信号处理 API。不是遗漏,而是信号语义跨平台差异太大,标准库选择不封装。默认行为是:Unix 上 Ctrl-C 给前台进程组发 SIGINT,默认动作是终止;Windows 上控制台收到 Ctrl-C 事件,默认也是终止。程序如果需要在退出前清理临时文件,就必须自己接管这个事件。

Unix 上用 libc::sigaction 注册处理函数,或者用 signal-hook、ctrlc 这类库;Windows 上用 SetConsoleCtrlHandler,同样有 ctrlc 封装。处理函数里只能做「设置一个原子标志」这种极简操作,真正的清理放到主循环里轮询标志执行。在信号处理函数里加锁、分配内存、打印日志都是不安全的,可能死锁或崩溃。这些代码本机没有实测,只说明方案。

还有一个更根本的问题:Drop 不保证执行。进程被 kill -9、被任务管理器结束、系统断电,都不会跑析构函数。所以「退出时清理临时文件」不能只依赖 Drop,要么在正常退出路径显式调用清理,要么在启动时做一次「扫描残留」的恢复逻辑。后者更可靠,因为它不依赖上一次是怎么死的。

Unix 上还有个「僵尸进程」的概念:子进程已经结束,但父进程还没 wait,内核会保留一条退出记录,等父进程来取。长期不取,进程表会被占满。Rust 的 Child 不会在析构时自动 wait,所以「spawn 了但从不 wait」的服务,跑久了会出现一堆僵尸。Windows 上没有僵尸这个概念,但未关闭的句柄同样会泄漏,只是表现不同。跨平台工具要养成「每个 Child 都有明确收尾路径」的习惯。

在 Unix 上,父进程被杀不会自动杀掉它启动的子进程。子进程会被重新挂到 init 或 systemd 下继续跑,留下「孤儿进程」。要管住整棵进程树,Unix 用进程组或 cgroup,Windows 用 Job Object。标准库都不提供,需要平台 API 或外部库。这段未在本机实测,但它是写守护进程必须知道的事。

现象对照

现象真实原因第一步查什么
脚本显示「完成」,实际任务失败只看了 stdout,没检查 ExitStatus改成 status.success() 判断,并记录退出码
父进程 wait 永远不返回子进程写满管道,父进程没读 stdout/stderr先读管道再 wait,或给每个流开读取线程
子进程一直等输入,不结束父进程只 flush 没关闭 stdindrop(child.stdin.take()) 发送 EOF
子进程结束后留下僵尸/句柄泄漏Child 析构不自动 wait所有路径都调用 wait,包括错误和超时路径
超时后 kill 了,进程还在kill 只发信号/终止请求,没有回收;子进程还可能忽略信号kill 后 wait,必要时升级为强制终止
用户输入带 ; 时执行了额外命令经过了 shell,字符串拼接导致注入不经过 shell,用 arg/args 直接传参
子进程找不到相对路径文件子进程工作目录与父进程不同显式 current_dir,或把路径转成绝对路径
Ctrl-C 后临时文件残留信号直接终止进程,Drop 不执行接管信号设标志,或在启动时扫描清理残留
退出码 None,逻辑判断失效进程被信号终止,没有正常退出码用 success(),跨平台再单独判断信号

边界与代价

第一层是控制力。父进程能做的只有「启动、传参、传环境、读写三个标准流、发终止请求、等结果」。子进程内部的线程、内存、文件句柄,父进程都看不到。想要更细的控制,得靠操作系统特有的机制:cgroup、Job Object、容器、ptrace。标准库故意停在「可移植的最小集」。

第二层是平台差异。信号、进程组、退出码含义、可执行文件查找规则、路径分隔符,每一项都可能不一样。写跨平台工具时,最好把平台相关部分隔离到单独模块,并且每个平台都真跑一遍。只在 Windows 上测过的超时逻辑,到 Linux 上可能因为信号语义不同而失败。

第三层是可观测性。子进程的输出、退出码、耗时、信号,都是排查问题的关键信息。只记录「命令执行失败」等于没记录。至少要把命令行、工作目录、退出码、stderr 的最后若干行写进日志,同时注意别把密码之类的参数原样打出来。

记录命令行本身也有讲究。直接把 args 拼成一个字符串打印,遇到带空格或引号的参数会产生歧义,事后想复现都复现不了。更好的做法是逐项记录参数数组,或者用平台提供的引用规则重新拼成一条「可以粘回终端」的命令。日志是给未来的自己看的,别在这上面省事。

第四层是安全。启动外部命令意味着信任那个程序;如果参数来自用户,还要防注入、防路径穿越、防资源耗尽。标准库不会替你做这些,Command 只是一个启动器。真正的安全边界在于「允许跑哪些程序、允许传什么参数」,这属于设计层面的白名单,而不是某个 API 的参数。

还有一条判断原则:不要用 stderr 的文字内容来判断成败。不同版本、不同语言环境、不同平台的错误文案都可能变,按「包含 error 关键字」做分支,迟早会失效。退出码是程序明确给出的信号,stderr 是给人看的说明。要结构化信息,就让被调用的程序输出 JSON,或者用专门的库,而不是解析自然语言。反过来,自己写给别人调用的脚本时,也要把退出码约定固定下来,错误信息随便改都不会影响调用方。

小结

把这一篇收成四句:只关心成败用 status,要短命令的输出用 output,长任务或要控制过程用 spawn;管道必须读,stdin 要关闭,kill 之后必须 wait;超时得自己轮询,标准库不给现成的;信号处理标准库没有,而且 Drop 在强制终止时不会执行。

到这里,单进程、单机的系统接口基本走完了:文件、网络、子进程。接下来进入并发——先看多个线程怎么共享一块状态,再看多个进程怎么共享一块内存。前者是 Arc/RwLock/原子操作,后者是 mmap 和 Unix socket。这两篇会反复回到同一个问题:共享的东西越多,协调的代价越大。

当天可以自己验证的练习:

  1. 写一个程序启动 cmd /C exit 3,分别用 status 和 output 拿结果,打印 code() 与 success()。
  2. 启动一个会输出 10 万行的子进程,故意只 wait 不读 stdout,观察它是否卡死。
  3. 给 spawn 加一个 3 秒超时,超时后 kill 再 wait,确认没有残留进程。
  4. 用 current_dir 把子进程的工作目录设到临时目录,确认相对路径的行为变化。
  5. 写一个接收 Ctrl-C 的最小程序(可以用 ctrlc 库),确认退出前能打印一行清理信息;本机没装依赖就只写代码并标注未实测。

这些练习覆盖了「启动、通信、收尾」三件事。真正写运维工具时,大部分 bug 都出在收尾和管道,而不是启动本身。