Go语言：通过通道实现Goroutine的精细化控制

package main

import (
    "fmt"
    "runtime"
    "sync"
    "time" // 引入time包用于模拟工作延迟
)

// 定义工作Goroutine的可能状态
const (
    Stopped = 0 // 停止状态
    Paused  = 1 // 暂停状态
    Running = 2 // 运行状态
)

// 定义工作Goroutine的数量
const WorkerCount = 5

func main() {
    // 使用sync.WaitGroup等待所有Goroutine完成
    var wg sync.WaitGroup
    wg.Add(WorkerCount + 1) // WorkerCount个工作Goroutine + 1个控制器Goroutine

    // 为每个工作Goroutine创建一个控制通道
    workers := make([]chan int, WorkerCount)
    for i := range workers {
        workers[i] = make(chan int, 1) // 使用带缓冲通道，避免发送阻塞

        // 启动工作Goroutine
        go func(id int, ws chan int) {
            worker(id, ws)
            wg.Done()
        }(i, workers[i])
    }

    // 启动控制器Goroutine
    go func() {
        controller(workers)
        wg.Done()
    }()

    // 等待所有Goroutine执行完毕
    wg.Wait()
    fmt.Println("所有Goroutine已停止。")
}

// worker函数定义了每个工作Goroutine的行为
func worker(id int, ws <-chan int) {
    state := Paused // 工作Goroutine初始状态为暂停

    for {
        select {
        case newState := <-ws: // 监听控制通道，接收新的状态命令
            switch newState {
            case Stopped:
                fmt.Printf("Worker %d: 接收到停止命令，正在退出...\n", id)
                return // 收到停止命令后退出Goroutine
            case Running:
                fmt.Printf("Worker %d: 接收到运行命令，开始工作。\n", id)
                state = Running
            case Paused:
                fmt.Printf("Worker %d: 接收到暂停命令，暂停工作。\n", id)
                state = Paused
            }

        default: // 如果控制通道没有新消息，则执行默认操作（即实际工作或等待）
            // 在此放置实际的工作逻辑
            if state == Running {
                fmt.Printf("Worker %d: 正在执行任务...\n", id)
                time.Sleep(100 * time.Millisecond) // 模拟工作耗时
            } else if state == Paused {
                // 如果处于暂停状态，为了避免CPU空转，可以调用runtime.Gosched()
                // 将CPU时间片让给其他Goroutine，或者在此处等待一段时间
                runtime.Gosched() // 协作式调度，让出CPU
                // fmt.Printf("Worker %d: 暂停中...\n", id) // 可选：打印暂停信息
                time.Sleep(50 * time.Millisecond) // 模拟短暂等待，避免CPU过度占用
            }
        }
    }
}

// controller函数负责管理所有工作Goroutine的状态
func controller(workers []chan int) {
    fmt.Println("\n--- 控制器启动 ---")

    // 1. 启动所有工作Goroutine
    fmt.Println("控制器：发送运行命令给所有Worker...")
    setState(workers, Running)
    time.Sleep(time.Second) // 运行一段时间

    // 2. 暂停所有工作Goroutine
    fmt.Println("\n控制器：发送暂停命令给所有Worker...")
    setState(workers, Paused)
    time.Sleep(2 * time.Second) // 暂停一段时间

    // 3. 恢复所有工作Goroutine
    fmt.Println("\n控制器：发送运行命令给所有Worker...")
    setState(workers, Running)
    time.Sleep(time.Second) // 再次运行一段时间

    // 4. 关闭所有工作Goroutine
    fmt.Println("\n控制器：发送停止命令给所有Worker...")
    setState(workers, Stopped)

    fmt.Println("--- 控制器完成 ---")
}

// setState是一个辅助函数，用于向所有工作Goroutine发送指定的状态命令
func setState(workers []chan int, state int) {
    for _, w := range workers {
        // 尝试发送状态，如果通道已满（理论上不会，因为是带缓冲通道且worker会及时读取），
        // 则可能需要更复杂的处理，但在此示例中，假定worker能够及时处理
        select {
        case w <- state:
            // 成功发送
        default:
            // 如果通道满了，表示worker处理不过来，可以记录日志或重试
            fmt.Printf("警告：无法向某个Worker发送状态 %d，通道可能已满。\n", state)
        }
    }
}