Swift并发中Process+NSPipe+NSFileHandle的正确异步等待实现

要在Swift并发环境下安全处理长时间运行的Process，核心是把传统的回调式handler转换成async/await可等待的形式，同时用Actor保证状态和IO操作的线程安全。以下是具体实现思路和代码：

核心思路 #

放弃信号量，改用Checked Continuation将Process的terminationHandler和管道的readabilityHandler回调逻辑桥接到Swift并发模型中，同时用Actor封装Process、管道以及输出收集的状态，确保所有操作串行执行，避免竞态条件。

具体实现 #

1. 定义处理Process的Actor #

Actor负责管理Process实例、管道、输出数据，以及所有回调逻辑的串行执行：

actor ProcessRunner {
    private var stdoutData = Data()
    private var stderrData = Data()
    
    func run(executableURL: URL, arguments: [String]) async throws -> (stdout: String, stderr: String) {
        let process = Process()
        process.executableURL = executableURL
        process.arguments = arguments
        
        // 创建标准输出和错误输出的管道
        let stdoutPipe = Pipe()
        let stderrPipe = Pipe()
        process.standardOutput = stdoutPipe
        process.standardError = stderrPipe
        
        // 配置输出读取的handler
        setupPipeReading(pipe: stdoutPipe, dataHandler: { [weak self] data in
            self?.stdoutData.append(data)
        })
        setupPipeReading(pipe: stderrPipe, dataHandler: { [weak self] data in
            self?.stderrData.append(data)
        })
        
        // 启动进程
        try process.run()
        
        // 用Continuation等待进程终止，并处理结果
        return try await withCheckedThrowingContinuation { continuation in
            process.terminationHandler = { [weak self, weak process] task in
                guard let self = self, let process = process else {
                    continuation.resume(throwing: NSError(domain: "ProcessRunner", code: -1, userInfo: [NSLocalizedDescriptionKey: "Process或Runner已释放"]))
                    return
                }
                
                // 关闭管道的读取句柄，释放资源
                stdoutPipe.fileHandleForReading.closeFile()
                stderrPipe.fileHandleForReading.closeFile()
                
                // 转换数据为字符串
                let stdout = String(data: self.stdoutData, encoding: .utf8) ?? ""
                let stderr = String(data: self.stderrData, encoding: .utf8) ?? ""
                
                // 重置输出数据，避免下一次运行污染
                self.stdoutData = Data()
                self.stderrData = Data()
                
                // 根据进程退出码决定是返回结果还是抛出错误
                if process.terminationStatus == 0 {
                    continuation.resume(returning: (stdout, stderr))
                } else {
                    continuation.resume(throwing: NSError(domain: "ProcessRunner", code: Int(process.terminationStatus), userInfo: [NSLocalizedDescriptionKey: "进程执行失败", "stderr": stderr]))
                }
            }
        }
    }
    
    // 封装管道读取的通用逻辑
    private func setupPipeReading(pipe: Pipe, dataHandler: @escaping (Data) -> Void) {
        let fileHandle = pipe.fileHandleForReading
        fileHandle.readabilityHandler = { handle in
            let data = handle.availableData
            if !data.isEmpty {
                dataHandler(data)
            }
        }
    }
}

2. 使用方式 #

在并发上下文（比如Task或async函数）中调用Actor的方法即可，自动等待进程完成并获取输出：

func testProcess() async {
    let runner = ProcessRunner()
    do {
        let result = try await runner.run(executableURL: URL(fileURLWithPath: "/usr/bin/sleep"), arguments: ["5"])
        print("标准输出：\(result.stdout)")
        print("错误输出：\(result.stderr)")
    } catch {
        print("执行出错：\(error)")
    }
}

关键细节说明 #

• Actor的作用：确保Process的启动、输出收集、终止处理等操作都在同一个串行执行上下文中，避免多线程操作共享状态（比如stdoutData）导致的竞态问题。
• Continuation的使用：将terminationHandler的回调逻辑转换成可await的任务，符合Swift并发的要求，同时避免了信号量阻塞线程的问题。
• 资源释放：在进程终止后必须关闭管道的读取句柄，否则会导致文件句柄泄漏，影响后续操作。
• 错误处理：根据Process的退出码判断执行是否成功，将错误信息（包括stderr内容）包装成Error抛出，方便上层处理。

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