Go 通道：select 语句与通道关闭

Go 语言通过通道（channel）实现 goroutine 之间的通信。select 语句是处理多个通道操作的核心机制，而正确关闭通道则是避免程序崩溃或死锁的关键。掌握这两者的配合使用，能写出更健壮的并发程序。

理解 select 语句的基本用法

select 语句监听多个通道的读写操作，一旦某个通道就绪，就执行对应的分支。它类似于 switch，但专门用于通道。

编写一个基础的 select 示例：

package main

import "fmt"

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)

    go func() { ch1 <- "来自 ch1" }()
    go func() { ch2 <- "来自 ch2" }()

    select {
    case msg1 := <-ch1:
        fmt.Println("收到:", msg1)
    case msg2 := <-ch2:
        fmt.Println("收到:", msg2)
    }
}

运行该程序，会随机打印其中一条消息，因为两个 goroutine 几乎同时向通道发送数据，select 会随机选择一个可执行的分支。

注意：如果所有通道都未就绪且没有 default 分支，select 会一直阻塞。

添加 default 分支避免阻塞

在 select 中加入 default 分支，可以让程序在没有通道就绪时立即执行默认逻辑，避免永久等待。

select {
case msg := <-ch:
    fmt.Println("收到消息:", msg)
default:
    fmt.Println("没有消息可读，继续做其他事")
}

使用 default 的典型场景：轮询通道的同时执行其他任务，比如定时检查、用户输入响应等。

正确关闭通道的意义

通道关闭后，不能再向其发送数据（否则 panic），但可以继续从中读取剩余数据，直到通道为空。

关闭通道的标准做法：由发送方关闭，接收方只负责读取。

ch := make(chan int, 3)
go func() {
    for i := 0; i < 3; i++ {
        ch <- i
    }
    close(ch) // 发送方主动关闭
}()

for v := range ch {
    fmt.Println(v) // 自动在通道关闭且无数据时退出循环
}

关键点：for range 循环会在通道关闭且缓冲区清空后自动终止，这是最安全的读取方式。

在 select 中检测通道是否关闭

当从已关闭的通道读取时，会立即返回该类型的零值，并且第二个返回值（ok 值）为 false。

在 select 中判断通道是否关闭：

select {
case v, ok := <-ch:
    if !ok {
        fmt.Println("通道已关闭，停止接收")
        return
    }
    fmt.Println("收到:", v)
}

务必检查 ok 值。如果不检查，可能把零值误认为有效数据（例如 int 类型的 0）。

多通道场景下的关闭处理

实际项目中常有多个通道同时工作。例如，一个主通道和一个退出信号通道。

实现带退出机制的 select 循环：

done := make(chan bool)
dataCh := make(chan string)

go func() {
    for i := 0; i < 5; i++ {
        dataCh <- fmt.Sprintf("数据 %d", i)
    }
    close(dataCh)
}()

go func() {
    time.Sleep(2 * time.Second)
    done <- true
}()

loop:
for {
    select {
    case v, ok := <-dataCh:
        if !ok {
            break loop
        }
        fmt.Println(v)
    case <-done:
        fmt.Println("收到退出信号")
        break loop
    }
}

使用标签（label）配合 break，可以从嵌套循环中直接跳出。这里 loop: 定义了外层循环的标签。

避免常见错误

错误 1：重复关闭通道

不要多次关闭同一个通道。Go 运行时会 panic。

ch := make(chan int)
close(ch)
// close(ch) // 再次关闭会导致 panic: close of closed channel

解决方案：确保只有一个 goroutine 负责关闭通道，通常是最先创建通道的那个。

错误 2：向已关闭通道发送数据

ch := make(chan int)
close(ch)
// ch <- 1 // panic: send on closed channel

解决方案：设计时明确“谁发送、谁关闭”，并通过文档或注释说明。

错误 3：忽略 ok 值导致误判

v := <-ch // 如果 ch 已关闭，v 是零值，但你不知道是数据还是关闭信号

始终使用 v, ok := <-ch 形式读取，尤其在 select 或循环中。

组合模式：生产者-消费者模型

结合 select 和通道关闭，构建一个完整的生产者-消费者示例。

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    jobs := make(chan int, 10)
    results := make(chan int, 10)
    done := make(chan bool)

    // 启动消费者
    var wg sync.WaitGroup
    for w := 1; w <= 3; w++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for job := range jobs {
                fmt.Printf("worker %d 处理任务 %d\n", id, job)
                time.Sleep(time.Millisecond * 100)
                results <- job * 2
            }
        }(w)
    }

    // 启动结果收集器
    go func() {
        wg.Wait()
        close(results)
        done <- true
    }()

    // 生产任务
    for i := 1; i <= 5; i++ {
        jobs <- i
    }
    close(jobs) // 关闭任务通道，通知消费者停止

    // 等待所有结果处理完毕
    <-done

    // 打印结果
    for res := range results {
        fmt.Println("结果:", res)
    }
}

分析流程：

1. 主 goroutine 创建 jobs 和 results 通道。
2. 启动多个消费者 goroutine，通过 for range jobs 持续读取。
3. 生产者发送完任务后 关闭 jobs 通道，消费者自动退出循环。
4. 使用 sync.WaitGroup 等待所有消费者结束，再 关闭 results 通道。
5. 主 goroutine 通过 done 信号知道何时可以安全读取 results。

最佳实践总结

记住：通道是引用类型，多个 goroutine 共享同一个通道变量。关闭操作影响所有使用者。

实战技巧：优雅终止长时间运行的 goroutine

很多后台任务需要响应关闭信号。使用 context 包配合通道是标准做法，但纯通道方案也清晰有效。

func worker(taskCh <-chan string, stopCh <-chan struct{}) {
    for {
        select {
        case task, ok := <-taskCh:
            if !ok {
                fmt.Println("任务通道关闭，worker 退出")
                return
            }
            process(task)
        case <-stopCh:
            fmt.Println("收到停止信号，worker 退出")
            return
        }
    }
}

func process(t string) {
    fmt.Println("处理:", t)
    time.Sleep(time.Second)
}

调用方式：

taskCh := make(chan string)
stopCh := make(chan struct{})

go worker(taskCh, stopCh)

taskCh <- "任务1"
taskCh <- "任务2"

// 模拟外部中断
time.Sleep(3 * time.Second)
close(stopCh) // 或发送 struct{}{}

// 或正常结束
// close(taskCh)

两种退出路径：

• 正常结束：关闭 taskCh
• 强制中断：向 stopCh 发送信号（或关闭它）

推荐使用 struct{} 作为信号类型，因为它不占用内存。

关闭通道是并发编程中的“收尾动作”，必须与 select 配合才能安全处理多路通信。始终让发送方关闭通道，接收方通过 ok 值或 range 循环感知关闭状态，就能避免绝大多数通道相关 bug。