Golang中如何判断通过`cmd.Start`启动的进程是否已完成

在Go中判断通过cmd.Start启动的进程是否已完成，最可靠的方法是使用ProcessState或结合Wait的非阻塞方式。以下是几种实现方案：

方案一：使用cmd.Process.Wait()（推荐）

虽然cmd.Wait()会阻塞，但可以通过goroutine实现非阻塞监控：

package main

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

func main() {
    cmd := exec.Command("sleep", "5")
    if err := cmd.Start(); err != nil {
        panic(err)
    }

    done := make(chan error, 1)
    go func() {
        done <- cmd.Wait()
    }()

    select {
    case err := <-done:
        fmt.Printf("进程已完成，错误信息: %v\n", err)
    case <-time.After(2 * time.Second):
        fmt.Println("进程仍在运行...")
    }
}

方案二：定期检查ProcessState

package main

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

func main() {
    cmd := exec.Command("sleep", "3")
    if err := cmd.Start(); err != nil {
        panic(err)
    }

    for {
        if cmd.ProcessState != nil && cmd.ProcessState.Exited() {
            fmt.Println("进程已完成")
            break
        }
        
        // 检查进程是否仍在运行
        if err := cmd.Process.Signal(os.Signal(syscall.Signal(0))); err != nil {
            fmt.Printf("进程已结束: %v\n", err)
            break
        }
        
        fmt.Println("进程仍在运行...")
        time.Sleep(1 * time.Second)
    }
}

方案三：使用os.FindProcess检查

package main

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

func main() {
    cmd := exec.Command("sleep", "2")
    if err := cmd.Start(); err != nil {
        panic(err)
    }

    pid := cmd.Process.Pid
    
    for {
        p, err := os.FindProcess(pid)
        if err != nil {
            fmt.Printf("进程查找失败: %v\n", err)
            break
        }
        
        // 发送信号0检查进程是否存在
        err = p.Signal(os.Signal(syscall.Signal(0)))
        if err != nil {
            fmt.Printf("进程已结束: %v\n", err)
            break
        }
        
        fmt.Println("进程仍在运行...")
        time.Sleep(500 * time.Millisecond)
    }
}

方案四：结合context和Wait

package main

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

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    cmd := exec.CommandContext(ctx, "sleep", "7")
    if err := cmd.Start(); err != nil {
        panic(err)
    }

    go func() {
        err := cmd.Wait()
        if err != nil {
            fmt.Printf("进程结束状态: %v\n", err)
        } else {
            fmt.Println("进程正常结束")
        }
    }()

    // 主程序继续执行其他任务
    for i := 0; i < 5; i++ {
        fmt.Println("执行其他任务...")
        time.Sleep(1 * time.Second)
    }
}

关键点说明：

1. cmd.ProcessState在进程结束后会被自动设置
2. 发送信号0的方法在Unix-like系统有效，Windows需使用不同方法
3. 最佳实践是使用goroutine配合cmd.Wait()，通过channel传递完成状态
4. 进程结束后，cmd.Process.Signal()会返回os.ErrProcessDone错误

这些方案都能在非阻塞的情况下监控进程状态，具体选择取决于你的使用场景和平台要求。