Go 中 channel 的 close 和 range 操作

在 Go 并发编程中，channel 是 goroutine 之间通信的核心机制。理解如何正确关闭 channel 以及使用 range 遍历 channel 是写出健壮并发程序的关键。本教程将循序渐进地讲解这两项操作，并提供可直接运行的代码示例。

Channel 关闭操作：close

close 内建函数用于关闭一个 channel。关闭操作由发送方执行，它向接收方传递“不再有数据发送”的信号。

基本语法

close(ch)

其中 ch 必须是双向 channel 或只发送 channel（chan<- T）。

关闭后的行为

• 发送：向已关闭的 channel 发送数据会引发 panic。
• 接收：接收方可以继续从已关闭的 channel 接收数据，直到缓冲区为空。当无数据可读时，会立即获得该 channel 元素类型的零值，且第二个返回值为 false。
• 重复关闭：对同一个 channel 执行多次 close 会引发 panic。
• 只读 channel：不允许关闭只接收 channel（<-chan T）。

ch := make(chan int, 2)
ch <- 1
ch <- 2
close(ch)

// 继续接收
v1, ok1 := <-ch  // 1, true
v2, ok2 := <-ch  // 2, true
v3, ok3 := <-ch  // 0, false (零值，通道已关闭且为空)

关闭的用途

关闭 channel 主要用于通知接收方数据流已结束。例如，在一个生产者-消费者模式中，生产者完成任务后关闭 channel，消费者据此退出读取循环。

使用 range 遍历 Channel

for...range 循环可以持续从 channel 中读取数据，直到 channel 被关闭且内部数据全部取出。它会自动处理“零值接收”的问题，是读取 channel 最简洁、最安全的方式。

语法

for value := range ch {
    // 处理 value
}
// 循环结束后，说明 ch 已关闭且为空

示例：单生产者-单消费者

package main

import "fmt"

func producer(ch chan<- int) {
    for i := 1; i <= 5; i++ {
        ch <- i
    }
    close(ch) // 生产者发送完毕后关闭 channel
}

func main() {
    ch := make(chan int)
    go producer(ch)

    // 消费者用 range 读取
    for v := range ch {
        fmt.Println("接收到:", v)
    }
    fmt.Println("channel 已关闭，循环结束")
}

输出：

接收到: 1
接收到: 2
接收到: 3
接收到: 4
接收到: 5
channel 已关闭，循环结束

为什么 range 是安全的？

• 无须手动检查 ok。
• 当 channel 关闭且读空后，循环自动终止，不会死锁。
• 代码更简洁、可读性更高。

常见的模式与最佳实践

1. 由发送方关闭 Channel

原则：只应由发送方关闭 channel，绝对不要让接收方关闭。
如果接收方关闭 channel，而发送方仍在发送，会导致发送 panic。

// 正确：发送方在确保不再发送后关闭
func send(data []int, ch chan<- int) {
    for _, v := range data {
        ch <- v
    }
    close(ch)
}

2. 使用 sync.WaitGroup 协调多个发送者

当多个 goroutine 同时发送时，需要在所有发送者完成后关闭 channel。通常使用 sync.WaitGroup 来控制。

func main() {
    ch := make(chan int)
    var wg sync.WaitGroup

    // 启动 3 个生产者
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            for j := 0; j < 3; j++ {
                ch <- id*10 + j
            }
        }(i)
    }

    // 等待所有生产者完成，然后关闭 channel
    go func() {
        wg.Wait()
        close(ch)
    }()

    // 消费者用 range 读取
    for v := range ch {
        fmt.Println(v)
    }
}

3. 单向 Channel 限制关闭权限

将 channel 作为函数参数时，可使用方向类型限制操作：

• chan<- T：只发送，允许关闭。
• <-chan T：只接收，不能关闭。

func receiver(ch <-chan int) {
    for v := range ch {
        // 处理数据…
    }
    // ch 不能在这里关闭，编译时就会报错
}

4. 如何安全地判断 Channel 是否关闭？

除了 range，还可以使用双值接收：

v, ok := <-ch
if !ok {
    // channel 已关闭且为空
}

但更推荐使用 range，除非你需要控制接收的流程。

陷阱与注意事项

• 忘记关闭导致死锁：如果主 goroutine 使用 range 读取一个永远不会关闭的 channel，且没有其他 goroutine 发送数据，程序会死锁。
• 向已关闭 channel 发送：这是最常见的 panic 原因。确保在所有发送操作结束后再关闭 channel，并且不要向已关闭的通道发送。
• 重复关闭：close 一个已经关闭的 channel 会 panic。可以考虑使用 sync.Once 或特殊的关闭信号 channel，但最简单的方式是明确只有一个 goroutine 负责关闭。
• 对 nil channel 的关闭：关闭一个 nil channel 也会 panic。
• 无缓冲 channel 的关闭顺序：无缓冲 channel 的关闭同样遵循“发送方关闭”的原则。如果接收方先退出，而发送方还在阻塞发送，可能导致死锁。

完整示例：多生产者-单消费者

package main

import (
    "fmt"
    "sync"
)

func main() {
    const numProducers = 4
    const numMessages = 3
    ch := make(chan string)

    var wg sync.WaitGroup

    // 启动多个生产者
    for p := 0; p < numProducers; p++ {
        wg.Add(1)
        go func(producerID int) {
            defer wg.Done()
            for m := 0; m < numMessages; m++ {
                ch <- fmt.Sprintf("生产者 %d: 消息 %d", producerID, m)
            }
        }(p)
    }

    // 等待所有生产者结束并关闭 channel
    go func() {
        wg.Wait()
        close(ch)
    }()

    // 消费者使用 range 读取所有消息
    for msg := range ch {
        fmt.Println(msg)
    }

    fmt.Println("所有消息已接收，程序退出")
}

总结

• close：由发送方调用，通知接收方数据结束；关闭后不能再发送，但可继续接收剩余数据。
• range：是从 channel 读取数据最自然的方式，自动处理关闭信号，代码简洁且不易出错。
• 协作模式：发送方在完成所有发送操作后关闭 channel，接收方用 range（或双值检查）优雅退出。
• 安全准则：谁发送，谁关闭；绝对不要让接收方关闭 channel；注意避免向已关闭 channel 发送数据。

掌握这两个操作，你就能构建出稳定、清晰的 Go 并发程序。动手尝试上面的示例，并尝试修改它们，以加深理解。