Go语言中高效处理子进程标准输出流的实践指南

package main

import (
    "fmt"
    "io"
    "log"
    "os"
    "os/exec"
    "time"
)

// stream 函数负责从管道读取数据并写入到os.Stdout
func stream(stdoutPipe io.ReadCloser) {
    defer stdoutPipe.Close() // 确保管道关闭
    buffer := make([]byte, 100, 1000) // 创建一个缓冲区
    for {
        n, err := stdoutPipe.Read(buffer) // 从管道读取数据
        if n > 0 {
            // 将读取到的数据写入父进程的标准输出
            if _, writeErr := os.Stdout.Write(buffer[0:n]); writeErr != nil {
                fmt.Fprintf(os.Stderr, "Error writing to os.Stdout: %v\n", writeErr)
                break
            }
        }
        if err == io.EOF {
            break // 读取到文件末尾，表示子进程输出结束
        }
        if err != nil {
            fmt.Fprintf(os.Stderr, "Error reading from pipe: %v\n", err)
            break // 发生其他读取错误
        }
    }
}

// do_my_own_thing 模拟父进程执行其他任务
func do_my_own_thing() {
    fmt.Println("父进程正在执行自己的任务...")
    time.Sleep(2 * time.Second)
    fmt.Println("父进程完成了自己的任务。")
}

func main() {
    // 假设有一个名为 my-program.go 的子进程程序，它会持续输出：
    // package main
    // import (
    //     "fmt"
    //     "time"
    // )
    // func main() {
    //     for i := 0; i < 5; i++ {
    //         fmt.Printf("子进程输出行 %d\n", i)
    //         time.Sleep(500 * time.Millisecond)
    //     }
    // }

    command := exec.Command("go", "run", "my-program.go")

    stdoutPipe, err := command.StdoutPipe()
    if err != nil {
        log.Fatalf("无法创建标准输出管道: %v", err)
    }

    if err := command.Start(); err != nil {
        log.Fatalf("无法启动子进程: %v", err)
    }

    // 在一个单独的Goroutine中处理子进程的输出流
    go stream(stdoutPipe)

    // 父进程可以继续执行其他任务，而子进程的输出正在被流式处理
    do_my_own_thing()

    // 等待子进程完成
    if err := command.Wait(); err != nil {
        log.Printf("子进程执行完毕，但返回错误: %v", err)
    } else {
        fmt.Println("子进程成功执行完毕。")
    }
}

package main

import (
    "fmt"
    "log"
    "os"
    "os/exec"
    "time"
)

// do_my_own_thing 模拟父进程执行其他任务
func do_my_own_thing() {
    fmt.Println("父进程正在执行自己的任务...")
    time.Sleep(2 * time.Second)
    fmt.Println("父进程完成了自己的任务。")
}

func main() {
    // 同样，假设有一个名为 my-program.go 的子进程程序，它会持续输出：
    // package main
    // import (
    //     "fmt"
    //     "time"
    // )
    // func main() {
    //     for i := 0; i < 5; i++ {
    //         fmt.Printf("子进程输出行 %d\n", i)
    //         time.Sleep(500 * time.Millisecond)
    //     }
    // }

    command := exec.Command("go", "run", "my-program.go")

    // 关键步骤：将子进程的Stdout直接重定向到父进程的Stdout
    // os.Stdout 实现了 io.Writer 接口
    command.Stdout = os.Stdout

    // 同样，如果需要重定向标准错误输出，可以这样做：
    // command.Stderr = os.Stderr

    if err := command.Start(); err != nil {
        log.Fatalf("无法启动子进程: %v", err)
    }

    // 父进程可以在子进程运行时执行其他任务，子进程的输出会自动打印
    do_my_own_thing()

    // 等待子进程完成
    if err := command.Wait(); err != nil {
        // command.Wait() 会返回子进程的退出状态错误，如果子进程以非零状态退出
        log.Printf("子进程执行完毕，但返回错误: %v", err)
    } else {
        fmt.Println("子进程成功执行完毕。")
    }
}