Go语言os/exec模块：优雅地管理外部进程生命周期

package main

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

func main() {
    // 创建一个命令对象，例如让系统休眠5秒
    cmd := exec.Command("sleep", "5")

    // 异步启动进程
    err := cmd.Start()
    if err != nil {
        log.Fatalf("无法启动进程: %v", err)
    }
    log.Printf("进程已启动，PID: %d", cmd.Process.Pid)

    // 在后台等待进程完成，以便后续回收资源
    // 实际应用中，Wait()通常在一个goroutine中调用，或在主逻辑中同步等待
    go func() {
        err := cmd.Wait()
        log.Printf("进程结束，错误信息: %v", err)
    }()

    log.Println("主程序继续执行...")
    // 模拟主程序执行其他任务，然后决定在3秒后终止sleep进程
    time.Sleep(3 * time.Second)
    // ... 此时如果sleep未被终止，将在这里进行终止操作
}

package main

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

func main() {
    cmd := exec.Command("sleep", "5")
    if err := cmd.Start(); err != nil {
        log.Fatalf("无法启动进程: %v", err)
    }
    log.Printf("进程已启动，PID: %d", cmd.Process.Pid)

    // 模拟在进程启动后立即或短时间内终止
    time.Sleep(1 * time.Second) // 等待1秒，确保进程已运行

    // 终止进程
    if err := cmd.Process.Kill(); err != nil {
        log.Fatalf("终止进程失败: %v", err)
    }
    log.Println("进程已强制终止。")

    // 必须调用Wait()来回收进程资源
    // 此时Wait()会返回一个错误，表明进程被信号终止
    if err := cmd.Wait(); err != nil {
        log.Printf("Wait()返回错误 (预期): %v", err)
    }
}

package main

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

func main() {
    // 创建一个带有3秒超时的上下文
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel() // 确保在函数退出时取消上下文，释放资源

    // 使用CommandContext启动命令，将上下文传递进去
    // 如果sleep 5秒的命令在3秒内未完成，它将被上下文终止
    cmd := exec.CommandContext(ctx, "sleep", "5")

    log.Println("尝试运行一个可能超时的进程...")
    err := cmd.Run() // Run()方法会启动进程并等待其完成

    if err != nil {
        // 检查错误是否是上下文超时引起的
        if ctx.Err() == context.DeadlineExceeded {
            log.Printf("进程因超时而终止: %v", err)
        } else {
            log.Fatalf("进程运行失败: %v", err)
        }
    } else {
        log.Println("进程成功完成。")
    }
}

package main

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

func main() {
    cmd := exec.Command("sleep", "5")
    if err := cmd.Start(); err != nil {
        log.Fatalf("无法启动进程: %v", err)
    }
    log.Printf("进程已启动，PID: %d", cmd.Process.Pid)

    // 创建一个channel用于接收进程完成的信号
    done := make(chan error, 1)
    go func() {
        done <- cmd.Wait() // 在goroutine中等待进程完成
    }()

    log.Println("等待进程完成或超时...")
    select {
    case <-time.After(3 * time.Second): // 3秒超时计时器
        // 超时发生，尝试终止进程
        if err := cmd.Process.Kill(); err != nil {
            log.Fatalf("终止进程失败: %v", err)
        }
        log.Println("进程因超时被终止。")
        // 此时，另一个goroutine中的cmd.Wait()会因进程被Kill而返回错误
        // 必须从done channel中读取这个错误，以避免goroutine泄漏
        <-done 
    case err := <-done: // 进程在超时前完成
        if err != nil {
            log.Fatalf("进程执行失败: %v", err)
        }
        log.Println("进程成功完成。")
    }
}