如何轮询进程的stdout/stderr输出？解决isEOF阻塞问题

嘿，我来帮你搞定这个恼人的问题！在Haskell里直接用isEOF检查子进程输出确实容易踩阻塞的坑——因为isEOF会一直等待直到句柄关闭或者有新数据，进程还在运行的时候就会卡得死死的。下面给你两种适配你提到依赖包的靠谱解决方案。

方法1：非阻塞读取+轮询输出 #

核心思路是用非阻塞的读取操作替代阻塞式检查，这样不管有没有数据都会立刻返回，不会卡住。我们可以写一个循环定期去拉取stdout和stderr的内容。

补全你的示例代码实现这个逻辑：

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE LambdaCase #-}
module Example where

import qualified Data.Text as T
import Data.Text (Text)
import Control.Monad (forever, unless, void)
import System.Process
import GHC.IO.Handle
import Data.String.Conversions
import Control.Concurrent (threadDelay)

runGhci :: Text -> IO Text
runGhci input = do
  -- 创建进程并绑定输入输出管道
  (Just stdinH, Just stdoutH, Just stderrH, procHandle) <-
    createProcess (proc "ghci" [])
      { std_in = CreatePipe
      , std_out = CreatePipe
      , std_err = CreatePipe
      , std_out_mode = NoBuffering  -- 禁用缓冲，确保实时拿到输出
      , std_err_mode = NoBuffering
      }

  -- 将输出句柄设为非阻塞模式
  hSetNonBlocking stdoutH True
  hSetNonBlocking stderrH True

  -- 向进程发送输入命令
  void $ cs input >>= hPutStr stdinH
  hFlush stdinH  -- 强制刷新输入，确保命令立刻发送

  -- 轮询读取输出的循环
  let pollOutput = do
        -- 非阻塞读取stdout（一次最多读4096字节）
        stdoutContent <- cs <$> hGetNonBlocking stdoutH 4096
        -- 非阻塞读取stderr
        stderrContent <- cs <$> hGetNonBlocking stderrH 4096

        -- 处理拿到的输出（这里简单打印，你可以改成收集或其他逻辑）
        unless (T.null stdoutContent) $
          putStrLn $ "[STDOUT] " <> T.unpack stdoutContent
        unless (T.null stderrContent) $
          putStrLn $ "[STDERR] " <> T.unpack stderrContent

        -- 检查进程是否结束，结束就退出循环
        isRunning <- getProcessExitCode procHandle
        case isRunning of
          Nothing -> threadDelay 100000 >> pollOutput  -- 未结束就等100ms再轮询
          Just _ -> pure ()

  pollOutput

  -- 读取进程结束后剩余的输出（可选）
  finalStdout <- cs <$> hGetContents stdoutH
  finalStderr <- cs <$> hGetContents stderrH
  pure $ finalStdout <> finalStderr

关键要点：

• 用hSetNonBlocking把输出句柄设为非阻塞模式，让hGetNonBlocking不会卡住
• 禁用输出缓冲，避免进程输出被系统缓冲住拿不到
• 用threadDelay控制轮询间隔，避免占用过多CPU
• 用getProcessExitCode判断进程状态，结束就停止轮询

方法2：并发读取两个输出流 #

如果不想手动轮询，更优雅的方式是用async库并发读取stdout和stderr，让两个流的读取互不干扰。需要先把async添加到你的依赖中。

代码示例：

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE LambdaCase #-}
module Example where

import qualified Data.Text as T
import Data.Text (Text)
import Control.Monad (void)
import System.Process
import GHC.IO.Handle
import Data.String.Conversions
import Control.Concurrent.Async (async, waitBoth)

runGhci :: Text -> IO Text
runGhci input = do
  (Just stdinH, Just stdoutH, Just stderrH, procHandle) <-
    createProcess (proc "ghci" [])
      { std_in = CreatePipe
      , std_out = CreatePipe
      , std_err = CreatePipe
      , std_out_mode = NoBuffering
      , std_err_mode = NoBuffering
      }

  -- 向进程发送输入命令
  void $ cs input >>= hPutStr stdinH
  hFlush stdinH

  -- 并发启动两个读取任务
  stdoutAsync <- async $ cs <$> hGetContents stdoutH
  stderrAsync <- async $ cs <$> hGetContents stderrH

  -- 等待两个读取任务完成（进程结束后句柄关闭，hGetContents会返回所有内容）
  (stdoutContent, stderrContent) <- waitBoth stdoutAsync stderrAsync

  -- 合并输出（你可以根据需求分别处理两个流的内容）
  pure $ stdoutContent <> stderrContent

这个方法的优势是不需要手动控制轮询，并发处理两个流，不会因为其中一个流没输出而阻塞另一个。hGetContents会在进程结束、句柄关闭时自动返回所有内容。

为什么isEOF会阻塞？ #

你遇到的问题本质是isEOF是阻塞操作：它会一直等待直到有数据可读或者句柄关闭。所以要么用非阻塞的方式读取/检查，要么用并发让两个流的读取互不干扰，就能避免卡住了。

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