如何实现Goroutine中计数操作的暂停、恢复与停止？

你的问题核心在于counter函数里的嵌套循环导致quit信号无法被及时响应：select的default分支里包含了一个从startFrom到99的完整循环，这个循环会持续执行直到结束，期间完全没有机会去检查quit通道的信号。只有当这个内部循环跑完后，才会回到外层的for循环进入select，这时候才能接收到quit信号，这就导致你发送stop命令后，goroutine不会立刻停止。

另外还有两个潜在问题：

• 无缓冲的quit通道在发送时可能阻塞main goroutine，因为如果目标goroutine没在接收，发送操作会一直等待。
• 多次输入start会启动多个独立的counter goroutine，这些goroutine都会独立运行，无法被统一控制。

下面是修复后的完整代码，同时实现了停止、暂停、恢复的功能：

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
    "time"
)

func main() {
    fmt.Println("starting...")
    reader := bufio.NewReader(os.Stdin)

    // 使用带缓冲的通道避免发送阻塞，同时用结构体统一管理控制信号
    ctrl := struct {
        quit   chan struct{} // 空结构体更节省内存
        pause  chan struct{}
        resume chan struct{}
    }{
        quit:   make(chan struct{}, 1),
        pause:  make(chan struct{}, 1),
        resume: make(chan struct{}, 1),
    }

    var counterIsRunning bool

    for {
        text, _ := reader.ReadString('\n')
        text = strings.TrimSpace(text)
        fmt.Printf("entered: %s\n", text)

        switch text {
        case "start":
            if !counterIsRunning {
                fmt.Println("starting counter")
                go counter(1, 1, ctrl)
                counterIsRunning = true
            } else {
                fmt.Println("counter is already running")
            }
        case "pause":
            if counterIsRunning {
                fmt.Println("pausing counter")
                // 避免重复发送导致通道阻塞
                select {
                case ctrl.pause <- struct{}{}:
                default:
                }
            }
        case "resume":
            if counterIsRunning {
                fmt.Println("resuming counter")
                select {
                case ctrl.resume <- struct{}{}:
                default:
                }
            }
        case "stop":
            if counterIsRunning {
                fmt.Println("stopping counter")
                // 确保quit信号只发送一次
                select {
                case ctrl.quit <- struct{}{}:
                default:
                }
                counterIsRunning = false
            }
        case "exit":
            fmt.Println("exiting program")
            // 退出前先停止counter goroutine
            if counterIsRunning {
                ctrl.quit <- struct{}{}
            }
            return
        default:
            fmt.Println("unknown command: supported commands are start/pause/resume/stop/exit")
        }
    }
}

func counter(startFrom int, multiplyBy int, ctrl struct {
    quit   <-chan struct{}
    pause  <-chan struct{}
    resume <-chan struct{}
}) {
    paused := false
    for x := startFrom; x < 100; x++ {
        select {
        case <-ctrl.quit:
            fmt.Println("\ncounter stopped")
            return
        case <-ctrl.pause:
            paused = true
        case <-ctrl.resume:
            paused = false
        default:
            if !paused {
                result := x * multiplyBy
                fmt.Printf("%d ", result)
                time.Sleep(time.Second)
            }
        }
    }
    fmt.Println("\ncounter finished naturally")
}

关键改动说明： #

• 移除嵌套循环：把原来default分支里的内部循环放到外层，每次迭代都通过select检查控制信号，确保quit/pause/resume信号能被及时响应。
• 统一控制信号：用结构体整合quit、pause、resume通道，同时使用struct{}{}空结构体作为通道元素，比bool类型更节省内存。
• 防止重复启动：用counterIsRunning变量标记goroutine运行状态，避免多次输入start启动多个独立的counter实例。
• 避免通道阻塞：发送控制信号时用select配合default分支，防止重复发送导致通道阻塞。
• 实现暂停/恢复：通过paused变量标记运行状态，仅在非暂停状态下执行计算和输出逻辑。

修改后，输入stop时counter goroutine会在下一次迭代立刻响应quit信号并退出；输入pause会暂停输出，resume则恢复执行。

内容的提问来源于stack exchange，提问作者Blankman