Go语言并发执行外部命令的协程池模式

package main

import (
    "os/exec"
)

func main() {
    cmd := exec.Command("zenity", "--info", "--text='Hello World'")
    err := cmd.Run() // .Run() 等同于 .Start() 后接 .Wait()
    if err != nil {
        // 实际应用中应处理错误
        panic(err)
    }
}

package main

import (
    "os/exec"
    "strconv"
)

func main() {
    numTasks := 8 // 假设需要执行8次
    for i := 0; i < numTasks; i++ {
        cmd := exec.Command("zenity", "--info", "--text='Hello from iteration n."+strconv.Itoa(i)+"'")
        err := cmd.Run()
        if err != nil {
            panic(err)
        }
    }
}

package main

import (
    "os/exec"
    "strconv"
    "time" // 引入 time 包用于演示
)

func callProg(i int) {
    cmd := exec.Command("zenity", "--info", "--text='Hello from iteration n."+strconv.Itoa(i)+"'")
    err := cmd.Run()
    if err != nil {
        // 在实际应用中，应将错误报告给主协程或日志系统
        println("Error executing command:", err.Error())
    }
}

func main() {
    numTasks := 8
    for i := 0; i < numTasks; i++ {
        go callProg(i) // 启动一个协程
    }
    // 问题：主协程可能在子协程执行前就退出
    // 简单的解决方案是等待一段时间，但这并非可靠的同步机制
    time.Sleep(5 * time.Second)
}

package main

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

// worker 函数：从任务通道接收命令并执行
func worker(id int, tasks <-chan *exec.Cmd, wg *sync.WaitGroup) {
    defer wg.Done() // 工作协程退出时通知 WaitGroup
    for cmd := range tasks {
        fmt.Printf("Worker %d: Executing command: %s %v\n", id, cmd.Path, cmd.Args)
        start := time.Now()
        err := cmd.Run()
        if err != nil {
            fmt.Printf("Worker %d: Error executing command '%s': %v\n", id, cmd.Path, err)
        }
        fmt.Printf("Worker %d: Command '%s' finished in %v\n", id, cmd.Path, time.Since(start))
    }
    fmt.Printf("Worker %d: Exiting.\n", id)
}

func main() {
    const (
        numTasks   = 20 // 总共要执行的任务数量
        numWorkers = 4  // 协程池中工作协程的数量，通常根据CPU核心数或I/O密集程度设定
    )

    // 1. 创建任务通道
    // 这是一个带缓冲的通道，用于存储待执行的 *exec.Cmd 任务
    // 缓冲区大小可以根据任务生成速度和消费速度调整，避免阻塞
    tasks := make(chan *exec.Cmd, numWorkers*2) // 缓冲通道大小可根据实际情况调整

    // 2. 初始化 WaitGroup
    var wg sync.WaitGroup

    // 3. 启动固定数量的工作协程
    for i := 0; i < numWorkers; i++ {
        wg.Add(1) // 每启动一个工作协程，WaitGroup计数器加1
        go worker(i+1, tasks, &wg)
    }

    // 4. 生成并发送任务到任务通道
    for i := 0; i < numTasks; i++ {
        cmd := exec.Command("zenity", "--info", "--text='Hello from iteration n."+strconv.Itoa(i)+"'")
        // 实际应用中，如果需要捕获输出或处理错误，可以设置 cmd.Stdout/Stderr
        // cmd.Stdout = os.Stdout
        // cmd.Stderr = os.Stderr
        tasks <- cmd // 将任务发送到通道
    }

    // 5. 关闭任务通道
    // 任务发送完毕后，必须关闭通道，以便工作协程知道没有更多任务会到来，从而优雅退出
    close(tasks)

    // 6. 等待所有工作协程完成
    // wg.Wait() 会阻塞主协程，直到 WaitGroup 计数器归零
    wg.Wait()

    fmt.Println("All tasks completed. Main program exiting.")
}