重定向标准输出后进程卡顿未完成的问题排查

问题场景 #

未重定向标准输出时，进程运行正常，终端能输出子进程的标准输出，最终显示Done with exit code 0；但重定向标准输出后，进程卡顿无法完成执行，调试发现卡在while (!process.StandardOutput.EndOfStream)循环的最后一次迭代。

未重定向时的代码 #

using (Process Proc = new Process())
{
   Proc.StartInfo.FileName = "Runner.exe";
   Proc.StartInfo.Arguments = $"...";
   Proc.StartInfo.WindowStyle = ProcessWindowStyle.Normal;
   Proc.StartInfo.UseShellExecute = false;
   Proc.StartInfo.CreateNoWindow = false;
   Proc.StartInfo.RedirectStandardOutput = false;
   Proc.Start();
   Proc.WaitForExit();
   int exitCode = Proc.ExitCode;
   Console.WriteLine($"Done with exit code {exitCode}");
}

重定向后的代码 #

using (Process Proc = new Process())
{
   Proc.StartInfo.FileName = "Runner.exe";
   Proc.StartInfo.Arguments = $"...";
   Proc.StartInfo.WindowStyle = ProcessWindowStyle.Normal;
   Proc.StartInfo.UseShellExecute = false;
   Proc.StartInfo.CreateNoWindow = false;
   Proc.StartInfo.RedirectStandardOutput = true;
   Proc.Start();

   while (!process.StandardOutput.EndOfStream)
   {
      string line = process.StandardOutput.ReadLine();
      Console.WriteLine(line);
   }
   Proc.WaitForExit();
   int exitCode = Proc.ExitCode;
   Console.WriteLine($"Done with exit code {exitCode}");
}

核心原因 #

1. 标准错误流缓冲区阻塞：子进程Runner.exe可能会向标准错误流（StandardError）输出内容，但代码仅重定向并读取了标准输出流。当错误流的缓冲区被填满后，子进程会暂停执行，等待缓冲区被读取；而父进程一直在等待标准输出流的EndOfStream，双方形成死锁，导致卡顿。
2. EndOfStream判断不可靠：子进程退出前可能不会主动关闭标准输出流，此时EndOfStream会一直返回false，父进程会无限等待。
3. 代码存在变量名不一致的笔误：定义的进程变量是Proc，循环中却使用process，不过这会直接引发编译错误，推测是书写时的疏忽，不是卡顿的直接原因。

解决方法 #

方法1：异步读取输出和错误流（推荐） #

通过注册事件异步读取两个流，避免单线程阻塞：

using (Process Proc = new Process())
{
   Proc.StartInfo.FileName = "Runner.exe";
   Proc.StartInfo.Arguments = "...";
   Proc.StartInfo.WindowStyle = ProcessWindowStyle.Normal;
   Proc.StartInfo.UseShellExecute = false;
   Proc.StartInfo.CreateNoWindow = false;
   Proc.StartInfo.RedirectStandardOutput = true;
   Proc.StartInfo.RedirectStandardError = true;

   // 注册标准输出接收事件
   Proc.OutputDataReceived += (sender, e) => 
   {
       if (!string.IsNullOrEmpty(e.Data))
           Console.WriteLine(e.Data);
   };
   // 注册标准错误接收事件
   Proc.ErrorDataReceived += (sender, e) => 
   {
       if (!string.IsNullOrEmpty(e.Data))
           Console.WriteLine($"Error: {e.Data}");
   };

   Proc.Start();
   // 启动异步读取
   Proc.BeginOutputReadLine();
   Proc.BeginErrorReadLine();

   Proc.WaitForExit();
   int exitCode = Proc.ExitCode;
   Console.WriteLine($"Done with exit code {exitCode}");
}

方法2：多线程同步读取 #

在单独线程中读取错误流，避免主线程阻塞：

using (Process Proc = new Process())
{
   Proc.StartInfo.FileName = "Runner.exe";
   Proc.StartInfo.Arguments = "...";
   Proc.StartInfo.UseShellExecute = false;
   Proc.StartInfo.CreateNoWindow = false;
   Proc.StartInfo.RedirectStandardOutput = true;
   Proc.StartInfo.RedirectStandardError = true;

   Proc.Start();

   // 开启线程读取标准错误流
   var errorReadTask = Task.Run(() => 
   {
       string errorLine;
       while ((errorLine = Proc.StandardError.ReadLine()) != null)
       {
           Console.WriteLine($"Error: {errorLine}");
       }
   });

   // 主线程读取标准输出流
   string outputLine;
   while ((outputLine = Proc.StandardOutput.ReadLine()) != null)
   {
       Console.WriteLine(outputLine);
   }

   // 等待错误流读取完成
   errorReadTask.Wait();
   Proc.WaitForExit();
   int exitCode = Proc.ExitCode;
   Console.WriteLine($"Done with exit code {exitCode}");
}

方法3：避免依赖EndOfStream #

用ReadLine()返回null判断输出结束，这比EndOfStream更可靠，因为当子进程关闭输出流后，ReadLine()会自动返回null：

// 替换原循环
string line;
while ((line = Proc.StandardOutput.ReadLine()) != null)
{
    Console.WriteLine(line);
}

内容的提问来源于stack exchange，提问作者user32882