Go语言实现与子进程的交互式通信

import sys

# 确保输出是无缓冲的，以便Go程序能立即接收到输出
sys.stdout.reconfigure(line_buffering=True)

while True:
    try:
        line = sys.stdin.readline()
        if not line: # EOF
            break
        result = eval(line.strip())
        sys.stdout.write(f'{result}\n')
        sys.stdout.flush() # 确保立即刷新缓冲区
    except Exception as e:
        # 简单错误处理，实际应用中可能需要更详细的日志
        sys.stderr.write(f"Error: {e}\n")
        sys.stderr.flush()
        break # 遇到错误退出循环

package main

import (
    "bufio"
    "fmt"
    "log"
    "os/exec"
    "time" // 用于模拟异步操作或延迟
)

func main() {
    // 1. 创建命令对象
    // "-u" 参数确保Python的stdout和stderr是无缓冲的，这对于实时交互非常重要
    cmd := exec.Command("python", "-u", "add.py")

    // 2. 获取子进程的stdin管道
    stdinPipe, err := cmd.StdinPipe()
    if err != nil {
        log.Fatalf("无法获取StdinPipe: %v", err)
    }
    defer stdinPipe.Close() // 确保在函数结束时关闭管道

    // 3. 获取子进程的stdout管道
    stdoutPipe, err := cmd.StdoutPipe()
    if err != nil {
        log.Fatalf("无法获取StdoutPipe: %v", err)
    }
    // 注意：这里不立即defer Close()，因为reader会持有管道，
    // 并且reader.ReadString('\n')会在EOF时返回错误，
    // 在循环结束后或进程退出时，由Cmd.Wait()间接处理或明确关闭。
    // 更安全的做法是在Read循环结束后显式关闭，或依赖Wait()。

    // 4. 创建一个bufio.Reader来高效地从stdout管道读取数据
    // 使用bufio可以按行读取，避免手动处理字节流的复杂性
    reader := bufio.NewReader(stdoutPipe)

    // 5. 启动子进程
    err = cmd.Start()
    if err != nil {
        log.Fatalf("无法启动子进程: %v", err)
    }
    log.Println("子进程已启动...")

    // 6. 与子进程进行交互：发送输入并读取输出
    for i := 0; i < 5; i++ {
        // 构造要发送的表达式
        expression := fmt.Sprintf("2+%d\n", i)

        // 写入数据到子进程的stdin
        _, err = stdinPipe.Write([]byte(expression))
        if err != nil {
            log.Fatalf("写入stdin失败: %v", err)
        }
        log.Printf("发送表达式: %q", expression)

        // 从子进程的stdout读取一行输出
        // ReadString('\n') 会读取直到遇到换行符，并包含换行符
        answer, err := reader.ReadString('\n')
        if err != nil {
            log.Fatalf("从stdout读取失败: %v", err)
        }
        // 打印结果，去除末尾的换行符
        fmt.Printf("表达式 %q 的答案是: %q\n", expression, answer)

        // 模拟一些延迟，以便观察交互过程
        time.Sleep(100 * time.Millisecond)
    }

    // 7. 关闭stdin管道，通知子进程输入结束
    // 这会导致Python脚本的sys.stdin.readline()返回空字符串，从而退出循环
    err = stdinPipe.Close()
    if err != nil {
        log.Printf("关闭stdin管道失败: %v", err)
    }
    log.Println("stdin管道已关闭，通知子进程输入结束。")

    // 8. 等待子进程退出
    // 这一步非常重要，它会阻塞直到子进程结束，并收集其退出状态
    err = cmd.Wait()
    if err != nil {
        // 如果子进程以非零状态码退出，Wait()会返回一个*ExitError
        log.Printf("子进程退出异常: %v", err)
    } else {
        log.Println("子进程正常退出。")
    }
}

2023/10/27 10:00:00 子进程已启动...
2023/10/27 10:00:00 发送表达式: "2+0\n"
表达式 "2+0\n" 的答案是: "2\n"
2023/10/27 10:00:00 发送表达式: "2+1\n"
表达式 "2+1\n" 的答案是: "3\n"
2023/10/27 10:00:00 发送表达式: "2+2\n"
表达式 "2+2\n" 的答案是: "4\n"
2023/10/27 10:00:00 发送表达式: "2+3\n"
表达式 "2+3\n" 的答案是: "5\n"
2023/10/27 10:00:00 发送表达式: "2+4\n"
表达式 "2+4\n" 的答案是: "6\n"
2023/10/27 10:00:00 stdin管道已关闭，通知子进程输入结束。
2023/10/27 10:00:00 子进程正常退出。