一个批处理程序要调用外部工具转码,代码写得很直白:启动进程,等它结束,再读输出。本地测试一直正常,到了生产环境,遇到大文件就卡住,进程不退出,CPU 也不高,看起来像在等什么。查了很久才发现,子进程的输出太多,把管道写满了,而父进程在等它结束,根本没去读。

这是多进程编程里最经典的一类死锁:父进程等子进程结束,子进程等父进程把管道里的数据读走。两边都没错,但顺序错了。类似的问题还有:只杀了父进程,子进程留下的孙进程还在跑;参数里带空格没转义,命令被拆成两段;退出码是 0,但输出里其实写着失败。

这篇讲 C# 里怎么启动和管理外部进程:Process 和 ProcessStartInfo 的基本用法、标准输出和标准错误的读取顺序、WaitForExit 到底等什么、退出码怎么判断、怎么杀掉整棵进程树。示例在本机 .NET 8 控制台项目里跑过,用 cmd.exe 作为子进程,命令和输出照实贴出。进程和线程在操作系统层面怎么调度的,可以回看 进程那一篇 和 线程调度那一篇。

先跑一个最小例子:启动、读输出、拿退出码

下面这段代码启动 cmd.exe,让它输出一行标准输出、一行标准错误,然后以退出码 3 结束。父进程把两路输出都读出来,再打印退出码:

using System;
using System.Diagnostics;

var psi = new ProcessStartInfo("cmd.exe")
{
    UseShellExecute = false,
    RedirectStandardOutput = true,
    RedirectStandardError = true,
    CreateNoWindow = true
};
psi.ArgumentList.Add("/c");
psi.ArgumentList.Add("echo out-line & echo err-line 1>&2 & exit 3");

using var p = Process.Start(psi)!;
var stdout = p.StandardOutput.ReadToEnd();
var stderr = p.StandardError.ReadToEnd();
p.WaitForExit();
Console.WriteLine($"out=[{stdout.Trim()}]");
Console.WriteLine($"err=[{stderr.Trim()}]");
Console.WriteLine($"code={p.ExitCode}");

本机 dotnet run 输出:

out=[out-line]
err=[err-line]
code=3

三行输出把关键信息都拿到了:标准输出、标准错误、退出码。注意读取顺序是先 ReadToEnd 再 WaitForExit,不是反过来。这个顺序不是风格问题,而是避免死锁的必要条件,下面会详细讲。

UseShellExecute = false 是重定向的前提。设为 true 时,系统会通过 shell 启动程序,标准输出和标准错误不能被重定向,RedirectStandardOutput 会直接失效。需要读输出、需要控制工作目录、需要传参数数组,都必须设为 false。

CreateNoWindow 控制是否创建新窗口。配合 UseShellExecute = false 使用时,可以避免弹出一个控制台窗口。如果只是启动一个后台工具,通常把它设为 true;如果需要用户看到窗口,就不用重定向,直接让系统处理。

参数怎么传,为什么不要拼字符串

ProcessStartInfo 有两个和参数相关的属性:Arguments 是一个完整字符串,ArgumentList 是一个字符串集合。前者需要自己处理空格和引号,后者由框架负责转义,更安全也更清楚。

看本文例子,如果拼成一个字符串,命令会变成 cmd.exe /c echo out-line & echo err-line 1>&2 & exit 3。其中 & 是 shell 的命令分隔符,稍不注意就会被解释成多条命令。用 ArgumentList 把 /c 和后面整段作为两个参数传进去,边界更明确。

不要把用户输入直接拼进 Arguments。用户输入里的空格、引号、&、| 都可能改变命令的含义,严重时会变成命令注入。能用 ArgumentList 就用它;必须拼字符串时,严格校验和转义,并且不要把用户输入当作命令本身。

工作目录用 WorkingDirectory 设置,不要指望子进程继承你想要的位置。环境变量可以通过 Environment 覆盖或追加,但要注意大小写:Windows 环境变量名不区分大小写,Linux 区分。需要给子进程传配置时,环境变量是一个比命令行参数更隐蔽的通道,记得在日志里脱敏。

能用可执行文件直接启动,就不要经过 cmd.exe /c。多一层 shell 意味着多一层转义规则,也多一个可能出问题的环节。本文用 cmd.exe 只是为了让例子在 Windows 上稳定复现,真实项目里如果目标是一个独立的 exe,直接写它的路径更清楚。

启动前最好确认可执行文件存在。路径写错时,Process.Start 会抛异常,但异常信息可能只告诉你「系统找不到指定的文件」,不告诉你是哪一段路径错了。把完整路径和当前工作目录一起打进日志,能省下很多时间。

为什么先 WaitForExit 再读输出会卡死

标准输出和标准错误不是直接连到你的屏幕,而是通过管道连接。管道有缓冲区,容量有限。子进程写满缓冲区后,如果父进程不来读,它就会阻塞在写操作上,无法继续执行,也就无法退出。父进程此时如果正在 WaitForExit,就会一直等一个永远不会结束的进程。

父进程与子进程的管道交互
父进程启动子进程
子进程写输出
管道缓冲区逐渐填满
父进程若等待退出
子进程阻塞在写
双方互相等待

本地测试为什么正常?因为输出少,管道缓冲区没满,子进程早就写完了,自然能退出。线上处理大文件、打开详细日志、输出大量进度信息时,数据量一大就触发。这个坑的可怕之处在于它不是每次都出现,而是和输出量有关,测试环境很难覆盖。

正确做法有三种。第一,在 WaitForExit 之前调用 ReadToEnd,把输出读完,再等退出。第二,用异步读取,比如 BeginOutputReadLine 配合事件,或者在新版 .NET 里用 ReadLineAsync 循环读。第三,把输出重定向到文件,让子进程直接写文件,父进程只等退出。三种都可以,关键是不要让「等待退出」和「读输出」串行成互相阻塞的顺序。

如果同时重定向了标准输出和标准错误,还要注意两路都要读。只读其中一路,另一路写满后同样会阻塞。简单场景可以两路分别 ReadToEnd,但要注意如果先读 stdout 直到结束、再读 stderr,而子进程在写 stderr 时阻塞,也可能卡住。更稳的方式是用异步事件同时消费两路,或者用两个线程分别读。

异步事件读取的骨架如下,两路各注册一个回调,收到一行就处理一行,不往内存里堆整个输出:

p.OutputDataReceived += (_, e) => { if (e.Data != null) Console.WriteLine("OUT " + e.Data); };
p.ErrorDataReceived += (_, e) => { if (e.Data != null) Console.WriteLine("ERR " + e.Data); };
p.BeginOutputReadLine();
p.BeginErrorReadLine();
p.WaitForExit();

这种方式适合输出量大、需要实时处理的场景。注意 e.Data 为 null 表示这一路输出结束,不要把它当成空行打印。事件回调在后台线程执行,如果回调里要更新界面或共享状态,记得做线程同步。

一个常见的错误写法是:先 WaitForExit(),再 ReadToEnd()。小输出时看不出问题,大输出时必卡。排查时如果发现子进程「活着但不干活」,先看它的输出量,再检查父进程的读取顺序。

WaitForExit 和退出码

WaitForExit() 不带参数时会一直等,直到进程结束。带超时的重载 WaitForExit(milliseconds) 会在超时后返回 false,但进程不一定真的结束,需要你自己处理。还有一种重载 WaitForExit(milliseconds, exitCode) 在新版里用来同时拿退出码,使用前确认目标框架支持。

退出码是子进程主动返回给父进程的一个整数。按惯例,0 表示成功,非 0 表示失败,但具体含义由子进程决定。有的工具用 1 表示一般错误,2 表示参数错误,有的工具用负数表示被信号终止。不能只看「是不是 0」,还要结合输出和文档判断。

if (p.ExitCode != 0)
{
    Console.WriteLine($"failed with {p.ExitCode}: {stderr}");
}

Windows 上被强制终止的进程,退出码可能是 -1 或其他特殊值。本文例子里,用 Kill(entireProcessTree: true) 杀掉一个正在 ping 的进程后,退出码就是 -1。所以不要用「退出码非 0」直接断定是业务失败,也要考虑进程是否被外部终止。

还有一个细节:WaitForExit() 无参版本在历史上还会等待输出异步读取完成,带超时的版本不一定。如果你用了异步事件读输出,等待退出后可能还有最后几行没处理完。判断「所有输出都读完了」不能只看进程退出,要结合读取任务是否结束。

运行中的进程还可以通过 HasExited 判断是否已经结束,通过 StartTime、ExitTime、TotalProcessorTime 拿到一些运行信息。但这些属性不是实时监控工具,频繁轮询开销不小,也不能替代事件和等待。需要精确的退出通知,还是用 WaitForExit 或 Exited 事件。

杀掉整棵进程树

很多外部工具自己还会启动子进程。比如一个脚本启动编译器,编译器再启动链接器。你只杀掉最外层的进程,里面的孙进程可能继续跑,占着文件、端口或 CPU。Windows 上可以用 Process.Kill(entireProcessTree: true) 一次性结束整棵树;Linux 上通常要结合进程组或 pkill 一类的方式处理。

var slow = Process.Start(new ProcessStartInfo("cmd.exe")
{
    UseShellExecute = false,
    CreateNoWindow = true,
    ArgumentList = { "/c", "ping -n 10 127.0.0.1 >nul" }
})!;
System.Threading.Thread.Sleep(200);
slow.Kill(entireProcessTree: true);
slow.WaitForExit();
Console.WriteLine($"killed hasExited={slow.HasExited} code={slow.ExitCode}");

本机输出:

killed hasExited=True code=-1

Kill 之后仍然建议调用 WaitForExit,让系统完成清理,避免留下僵尸进程或句柄。直接 Kill 不给子进程保存状态的机会,只适合确实需要立即终止的场景。更温和的做法是先发一个「请退出」的信号或命令,等一小段时间,再不退才强杀。

杀掉进程树不等于清理干净。子进程可能已经写了半截文件、占着锁、留下了临时目录。业务上要定义好「中断后怎么恢复」:临时文件放哪里、下次启动怎么识别、要不要做补偿。这些不是 Process API 能解决的。

标准输入、交互与超时

需要给子进程喂数据时,设置 RedirectStandardInput = true,然后通过 p.StandardInput.WriteLine 写入。写完要关闭输入流,或者写入约定的结束标记,否则子进程可能一直等更多输入。交互式程序还可能等待终端特性,重定向之后行为会变,能不用交互模式就不用。

超时控制要自己实现。一种做法是用 WaitForExit(timeout),超时后调用 Kill;另一种是把等待包装成任务,用 Task.WhenAny 加一个延迟任务竞速,谁先完成就处理谁。后一种更灵活,但要注意取消和资源释放,别让延迟任务一直挂着。

读取输出也可能需要超时。如果子进程卡住不写,ReadToEnd 会一直等。把读取放到独立任务里,配合取消令牌或超时监控,才能在规定时间内放弃。多进程编程里,「等」是最容易出问题的地方,凡是等待都要想清楚:等什么、等多久、等不到怎么办。

编码也要显式处理。StandardOutputEncoding 和 StandardErrorEncoding 可以指定按什么字符集解码子进程的输出。默认值依赖于系统区域设置,中文 Windows 和 Linux 容器可能不同。子进程输出 UTF-8,父进程却按 GBK 解码,就会看到乱码;反之亦然。统一约定 UTF-8,并在两端都显式设置,是最省心的做法。

真实项目里的现象与排查方向

现象真实原因第一步查什么
子进程输出多时父进程卡住先 WaitForExit 再读输出,管道缓冲区被写满检查读取和等待的顺序,改成先读或异步读
只读 stdout,stderr 很多时也卡住标准错误同样走管道,没人消费就会阻塞确认两路输出都有读取逻辑
启动失败,提示找不到文件UseShellExecute 为 false 时不会走 shell 查找,路径必须明确检查可执行文件路径和工作目录,必要时写绝对路径
参数带空格被拆成多个用 Arguments 拼字符串,引号没有正确转义改用 ArgumentList,或检查引号是否成对
退出码是 0,实际却失败了子进程没有正确返回失败码,或把错误写进了标准输出同时检查 stdout 和 stderr 的内容,不只看退出码
杀掉父进程后还有进程在跑只杀了最外层,没有处理子进程树改用 Kill(entireProcessTree: true),或在系统层面管理进程组
Kill 后退出码是 -1进程被强制终止,不是正常退出区分「业务失败」和「被外部终止」,日志里记录终止原因
程序退出后留下临时文件子进程被中断,没来得及清理设计可恢复的临时目录命名和启动时清理策略

排查多进程问题时,先确认子进程到底有没有在跑、有没有在写输出、有没有在等输入。任务管理器或系统工具看到的是现象,管道和退出码才是原因。不要一上来就怀疑 C# 的 Process API 有 bug,绝大多数问题都出在等待顺序和资源消费上。

边界与代价

  • 启动进程比调用方法贵得多:创建进程、加载程序、初始化运行时都有开销。高频小任务不要每次都起一个新进程,能复用就复用,能合批就合批。
  • 进程之间没有共享内存:数据要通过参数、标准输入输出、文件或网络传递。传大对象时序列化和复制的成本很高,设计时要考虑数据量。
  • 平台差异明显:Windows 和 Linux 的路径、信号、进程树管理方式不同。写跨平台工具时,命令、参数、终止方式都要分别验证。
  • 退出码约定不统一:不同工具对非 0 值的定义不同,不能用一个通用映射解释所有失败。要么读文档,要么把输出一起记录下来。
  • 强制终止有代价:Kill 不会给子进程清理机会,可能留下半截文件或未释放的锁。重要任务要设计优雅退出和恢复流程。
  • 权限和安全边界:父进程以什么用户运行,子进程就继承什么权限。不要用高权限账户启动不受信任的外部程序。

还有一个容易忽略的点:子进程的标准输出如果一直不读,不只是卡住,还可能让日志丢失。管道缓冲区满后,子进程的写操作被阻塞,后面的日志根本产生不出来。排查线上问题时,这会让你看不到最关键的那几行。

当天能自己验证的练习

以下练习都在一个控制台项目里完成,改 Program.cs 后执行 dotnet run:

  1. 跑通本文第一个例子,确认标准输出、标准错误、退出码三样都能拿到;然后把 ReadToEnd 和 WaitForExit 调换顺序,观察小输出时是否仍然正常。
  2. 把子进程的命令改成输出一万行文本,再调换读取和等待的顺序,观察是否卡住;用任务管理器确认子进程状态。
  3. 只重定向标准输出、不重定向标准错误,让子进程往 stderr 写大量内容,观察父进程是否被拖住。
  4. 用 ArgumentList 启动一个带空格参数的命令,再把同样的参数拼成 Arguments 字符串,对比两次的实际行为。
  5. 启动一个会再启动子进程的脚本,先用普通 Kill,再用 Kill(entireProcessTree: true),通过系统工具确认两种方式分别留下了哪些进程。
练习时不要杀系统关键进程,也不要用高权限账户启动外部程序。用 cmd.exe、ping 这类无害命令就够了。观察进程树可以用系统自带的任务管理器或命令行工具,不需要额外安装软件。

小结

三句话收一下:启动子进程用 ProcessStartInfo,参数优先用 ArgumentList;重定向输出后要先读或异步读,再等退出,否则管道写满就会死锁;退出码只是结果的一部分,要结合输出判断,杀进程要考虑整棵进程树和清理成本。

进程是操作系统层面的隔离单位,线程则是同一进程内的执行单位。下一篇讲 C# 的多线程:Thread 和 Task.Run 有什么区别、lock 到底锁了什么、ConcurrentDictionary 能解决哪些问题,以及线程池饥饿是怎么发生的。