Go并发分段求和：理解并避免通道死锁

1. Go并发分段求和场景概述

在Go语言中，利用goroutine实现并发任务是常见的优化手段。例如，当需要计算一个大型数组所有元素的和时，可以将其分成若干段，然后为每段启动一个goroutine并行计算其子和，最后将所有子和汇总。这种模式通常会用到通道（channel）来传递各个goroutine的计算结果。

考虑以下一个简单的并发求和示例，它将一个整数数组a分成两部分，然后启动两个Add goroutine分别计算这两部分的和，并通过一个通道ch将结果发送回主goroutine进行汇总：

package main

import (
    "fmt"
)

// Add 函数计算切片a中所有元素的和，并将结果发送到通道res。
func Add(a []int, res chan<- int) {
    sum := 0
    for _, val := range a {
        sum += val
    }
    res <- sum // 将计算结果发送到通道
}

func main() {
    a := []int{1, 2, 3, 4, 5, 6, 7}

    n := len(a)
    ch := make(chan int) // 创建一个无缓冲通道

    // 启动两个goroutine分别计算数组两部分的和
    go Add(a[:n/2], ch)
    go Add(a[n/2:], ch)

    sum := 0
    // 尝试从通道接收结果并汇总
    for s := range ch {
        sum += s
    }
    // close(ch) // 原始代码中此处被注释或缺失

    fmt.Println(sum)
}

2. 死锁问题分析

上述代码在运行时会发生死锁。其根本原因在于主goroutine中对通道ch的for s := range ch循环。

Go语言中，for range循环在通道上工作时，会持续从通道接收值，直到通道被关闭。如果通道永远不被关闭，那么for range循环将无限期地等待新的值。在我们的示例中，两个Add goroutine完成它们的计算并将结果发送到ch后就会退出。此后，没有任何goroutine会向ch发送数据，也没有任何goroutine会关闭ch。因此，主goroutine中的for range ch循环在接收完两个结果后，会继续等待第三个、第四个……值，而这些值永远不会到来，导致程序进入死锁状态。

简单来说，死锁发生的原因是：

1. 所有发送方（Add goroutine）都已经完成并退出。
2. 接收方（主goroutine的for range ch）仍在等待更多数据。
3. 通道ch从未被关闭，无法向接收方发出“不再有数据”的信号。

3. 解决方案：使用计数器机制

为了解决这个死锁问题，我们需要确保主goroutine知道何时停止从通道接收数据。对于固定数量的发送方（本例中有两个Add goroutine），最直接且无需关闭通道的方法是使用一个计数器。主goroutine可以明确地知道它需要接收多少个结果，然后在一个循环中精确地接收这些数量的值。

易笔AI论文

专业AI论文生成，免费生成论文大纲，在线生成选题/综述/开题报告等论文模板

103

查看详情

以下是使用计数器机制修正后的main函数：

package main

import (
    "fmt"
)

// Add 函数与之前相同
func Add(a []int, res chan<- int) {
    sum := 0
    for _, val := range a {
        sum += val
    }
    res <- sum
}

func main() {
    a := []int{1, 2, 3, 4, 5, 6, 7}

    n := len(a)
    ch := make(chan int) // 创建一个无缓冲通道

    // 启动两个goroutine
    go Add(a[:n/2], ch)
    go Add(a[n/2:], ch)

    sum := 0
    // 明确知道有两个goroutine会发送结果，因此循环两次
    for i := 0; i < 2; i++ { // 或者使用一个计数变量，如 `count := 0; for count < 2 { ... count++ }`
        s := <-ch // 从通道接收一个结果
        sum += s
    }
    // 在这种方法下，不需要关闭通道，因为我们已经明确接收了所有预期结果。

    fmt.Println(sum) // 输出最终结果
}

在这个修正后的代码中：

• 我们不再使用for range ch循环，而是使用一个for循环，该循环会迭代固定的次数（本例中为2次），因为我们知道有两个Add goroutine会发送结果。
• 每次循环，主goroutine通过s := <-ch从通道接收一个结果。
• 当循环完成时，主goroutine已经接收了所有预期的结果，并可以继续执行后续逻辑，而不会陷入无限等待。
• 由于我们不依赖range循环来判断通道是否关闭，因此无需手动关闭通道。

4. 注意事项与最佳实践

1. 何时关闭通道？

   • 通常情况下，只有发送方（或一个明确的协调者）才应该关闭通道，并且只关闭一次。
   • 关闭通道的目的是向接收方发出信号，表明不再有数据会发送到该通道。
   • 如果通道有多个发送方，关闭通道的时机需要仔细协调，以避免在其他发送方仍在尝试发送数据时关闭通道，这会导致panic。
   • 在上述计数器方案中，由于接收方知道要接收多少个值，因此通道是否关闭变得不那么重要，甚至可以不关闭。

2. sync.WaitGroup 的应用 对于更复杂的并发场景，尤其是有N个发送方且N可能动态变化时，sync.WaitGroup 是一个更强大和更Go惯用的工具。WaitGroup 可以用来等待一组goroutine完成。结合WaitGroup，我们可以更优雅地管理通道的关闭：

   package main
   
   import (
       "fmt"
       "sync"
   )
   
   func AddWithWG(a []int, res chan<- int, wg *sync.WaitGroup) {
       defer wg.Done() // goroutine完成时通知WaitGroup
       sum := 0
       for _, val := range a {
           sum += val
       }
       res <- sum
   }
   
   func main() {
       a := []int{1, 2, 3, 4, 5, 6, 7}
       n := len(a)
       ch := make(chan int)
       var wg sync.WaitGroup // 声明一个WaitGroup
   
       // 启动两个goroutine
       wg.Add(1) // 增加计数器，表示有一个goroutine即将启动
       go AddWithWG(a[:n/2], ch, &wg)
   
       wg.Add(1) // 增加计数器
       go AddWithWG(a[n/2:], ch, &wg)
   
       // 启动一个匿名goroutine来等待所有工作goroutine完成并关闭通道
       go func() {
           wg.Wait() // 等待所有wg.Done()被调用
           close(ch) // 当所有发送方都完成后，关闭通道
       }()
   
       sum := 0
       // 现在可以使用for range安全地从通道接收数据，因为它最终会被关闭
       for s := range ch {
           sum += s
       }
   
       fmt.Println(sum)
   }

   登录后复制

   这种sync.WaitGroup的模式是处理多生产者单消费者场景下通道关闭的推荐做法，它使得for range循环能够正确终止。

5. 总结

在Go语言并发编程中，理解通道的生命周期和for range在通道上的行为至关重要。当使用通道从多个goroutine接收结果时，如果接收方依赖for range循环，必须确保通道在所有预期数据发送完毕后被关闭。对于固定数量的生产者，可以通过显式计数循环来避免对通道关闭的依赖。而对于更复杂的场景，结合sync.WaitGroup来协调goroutine的完成和通道的关闭，是更健壮和推荐的解决方案。正确管理通道的关闭是避免死锁和编写可靠并发程序的关键。

以上就是Go并发分段求和：理解并避免通道死锁的详细内容，更多请关注php中文网其它相关文章！