在并发编程中，Channel 是一种常用的 Goroutine 间通信方式。当多个 Goroutine 向同一个 Channel 发送数据时，如何安全地关闭该 Channel是一个常见的问题。如果在某个 Goroutine 中直接关闭 Channel，可能会导致其他 Goroutine 尝试向已关闭的 Channel 发送数据，从而引发 panic。本文将介绍一种使用 sync.WaitGroup 来安全关闭 Channel 的方法。
sync.WaitGroup 用于等待一组 Goroutine 完成。它可以跟踪一组 Goroutine 的完成情况，并在所有 Goroutine 完成后发出信号。我们可以利用 sync.WaitGroup 来确保在所有 Goroutine 都完成发送后，再关闭 Channel。
以下是一个使用 sync.WaitGroup 安全关闭 Channel 的示例：
package main
import (
"fmt"
"sync"
)
const WorkerCount = 10
func main() {
// 一些输入数据用于操作。
// 每个 worker 获得相同大小的份额来处理。
data := make([]int, WorkerCount*10)
for i := range data {
data[i] = i
}
// 对所有条目求和。
result := sum(data)
fmt.Printf("Sum: %d\n", result)
}
// sum 通过将操作委托给并行处理输入数据子切片的 worker，将给定列表中的数字相加。
func sum(data []int) int {
var sum int
result := make(chan int)
// 从 worker 累积结果。
go func() {
for value := range result {
sum += value
}
}()
// WaitGroup 将跟踪所有 worker 的完成情况。
wg := new(sync.WaitGroup)
wg.Add(WorkerCount)
// 将工作分配到 worker 的数量上。
chunkSize := len(data) / WorkerCount
// 启动 worker。
for i := 0; i < WorkerCount; i++ {
go func(i int) {
offset := i * chunkSize
worker(result, data[offset:offset+chunkSize])
wg.Done()
}(i)
}
// 等待所有 worker 完成，然后返回结果。
wg.Wait()
close(result) // 安全关闭 Channel
return sum
}
// worker 对给定列表中的数字求和。
func worker(result chan int, data []int) {
var sum int
for _, v := range data {
sum += v
}
result <- sum
}代码解释：
-
sync.WaitGroup 的使用：
- wg := new(sync.WaitGroup) 创建一个新的 sync.WaitGroup 实例。
- wg.Add(WorkerCount) 设置等待的 Goroutine 数量。
- wg.Done() 在每个 worker Goroutine 完成时调用，表示一个 Goroutine 完成。
- wg.Wait() 阻塞当前 Goroutine，直到所有等待的 Goroutine 都调用了 wg.Done()。
-
Channel 的安全关闭：
- close(result) 在 wg.Wait() 之后调用，确保所有 worker Goroutine 都已完成发送操作，才关闭 Channel。
- 使用 for value := range result 来接收channel数据，当channel关闭后会自动退出循环，避免死锁。
注意事项：
- 确保在所有 Goroutine 完成发送后，才关闭 Channel。
- 使用 sync.WaitGroup 可以有效地跟踪 Goroutine 的完成情况，从而安全地关闭 Channel。
- 使用 for...range 结构来读取channel数据，可以避免读取已经关闭的channel。
总结：
使用 sync.WaitGroup 是一种安全可靠地关闭多 Goroutine 发送数据的 Channel 的方法。通过跟踪 Goroutine 的完成情况，我们可以确保在所有 Goroutine 完成发送后，才关闭 Channel，避免向已关闭的 Channel 发送数据导致的 panic。 这种模式在并发编程中非常有用，特别是在需要并行处理数据并将结果发送到单个 Channel 的场景中。
