如何在defer块中安全关闭Channel？Go协程优雅终止问题解惑

为什么睡眠时长会影响结果？ #

你的代码有两个核心问题导致了这种差异：

1. 无缓冲通道的阻塞特性：done是无缓冲通道，done <- true会一直阻塞，直到有goroutine接收这个值。
2. break的作用域错误：你在select的done分支里用的break只能跳出当前select，无法终止外层的for循环——哪怕子goroutine收到了终止信号，也会立刻回到for循环继续等待。
3. Go程序的退出规则：Go程序会在主goroutine执行完毕后，立即终止所有其他goroutine，不管它们处于什么状态。

具体到两种时长的差异：

• 睡眠7秒时：主goroutine醒来后进入defer，执行done <- true开始阻塞。此时子goroutine可能刚处理完6秒的ticker触发，正处于回到select的调度间隙。即使子goroutine收到信号，也会因为break没跳出循环立刻回到select，而主goroutine很快完成发送并关闭通道，随后主goroutine退出，子goroutine被强制终止，你来不及看到DONE!的打印。
• 睡眠8秒时：主goroutine醒来时，子goroutine刚好在处理8秒的ticker触发，完成打印后回到select，此时主goroutine的done <- true能被立即接收，子goroutine打印DONE!后你能看到这个输出。

如何优雅终止goroutine？ #

推荐两种标准方案：

方案1：修正循环终止逻辑 #

把select分支里的break换成return，直接终止子goroutine：

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(2 * time.Second)
    defer ticker.Stop() // 及时停止ticker，避免资源泄漏
    done := make(chan bool)

    go func(ticker *time.Ticker, done chan bool) {
        for {
            select {
            case <-done:
                fmt.Println("DONE!")
                return // 直接终止goroutine
            case <-ticker.C:
                fmt.Println("TICK!...")
            }
        }
    }(ticker, done)

    time.Sleep(7 * time.Second)
    fmt.Println("exiting..")
    done <- true
    close(done)
}

方案2：使用Context（官方推荐） #

context是Go标准库提供的优雅终止goroutine的方案，无需手动管理通道：

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel() // 确保程序退出时触发终止信号

    ticker := time.NewTicker(2 * time.Second)
    defer ticker.Stop()

    go func(ctx context.Context, ticker *time.Ticker) {
        for {
            select {
            case <-ctx.Done():
                fmt.Println("DONE!")
                return
            case <-ticker.C:
                fmt.Println("TICK!...")
            }
        }
    }(ctx, ticker)

    time.Sleep(7 * time.Second)
    fmt.Println("exiting..")
}

如何在defer块中安全关闭通道？ #

遵循三个核心原则：

1. 只有发送者关闭通道：避免接收者关闭通道，导致发送者触发panic。
2. 避免重复关闭：可以用sync.Once保证只关闭一次，或者通过逻辑设计避免重复触发关闭。
3. 避免发送阻塞：如果用无缓冲通道，确保发送操作不会阻塞主goroutine。

针对你的场景，推荐两种安全实现：

方式1：使用带缓冲的通道 #

给done通道设置缓冲大小为1，这样done <- true不会阻塞：

done := make(chan bool, 1)
defer func() {
    fmt.Println("exiting..")
    done <- true
    close(done)
}()

方式2：用select避免发送阻塞 #

如果必须用无缓冲通道，用select配合default避免发送阻塞：

defer func() {
    fmt.Println("exiting..")
    select {
    case done <- true:
        // 发送成功
    default:
        // 无接收者，跳过发送
    }
    close(done)
}()

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