Go协程实现等待多个协程完成的方法

在Go语言的并发编程中，经常会遇到启动多个协程并行执行任务，然后需要等待所有协程都完成后再进行后续操作的场景。掌握有效的方法来等待多个协程完成，对于构建高效、可靠的并发程序至关重要。

一种常用的方式是使用 sync.WaitGroup。sync.WaitGroup 内部维护着一个计数器，通过 Add 方法增加计数，Done 方法减少计数，Wait 方法则会阻塞当前协程，直到计数器归零。例如，我们有一个需求，需要启动多个协程去计算数组中每个元素的平方，代码如下：

package main

import (
    "fmt"
    "sync"
)

func squareArray(arr []int, wg *sync.WaitGroup) {
    defer wg.Done()
    for i := range arr {
        arr[i] = arr[i] * arr[i]
    }
}

func main() {
    var wg sync.WaitGroup
    numbers := []int{1, 2, 3, 4, 5}
    numCoroutines := 2

    partSize := len(numbers) / numCoroutines
    for i := 0; i < numCoroutines; i++ {
        wg.Add(1)
        start := i * partSize
        end := (i + 1) * partSize
        if i == numCoroutines-1 {
            end = len(numbers)
        }
        go squareArray(numbers[start:end], &wg)
    }

    wg.Wait()
    fmt.Println(numbers)
}

在上述代码中，我们启动了多个协程来处理数组的不同部分，每个协程完成任务后通过 wg.Done() 通知 WaitGroup。主协程调用 wg.Wait() 等待所有协程完成。

另一种方法是利用 sync.Cond 结合 sync.Mutex。sync.Cond 可以在满足特定条件时通知等待的协程。不过相比 sync.WaitGroup，这种方式实现起来更为复杂，常用于需要更精细控制的场景。

还有一种基于通道（Channel）的方式。可以创建一个信号通道，每个协程完成任务后向通道发送一个信号，主协程通过接收通道信号来判断所有协程是否完成。

package main

import (
    "fmt"
)

func squareArrayChannel(arr []int, signal chan struct{}) {
    defer func() {
        signal <- struct{}{}
    }()
    for i := range arr {
        arr[i] = arr[i] * arr[i]
    }
}

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    numCoroutines := 2
    signal := make(chan struct{}, numCoroutines)

    partSize := len(numbers) / numCoroutines
    for i := 0; i < numCoroutines; i++ {
        start := i * partSize
        end := (i + 1) * partSize
        if i == numCoroutines-1 {
            end = len(numbers)
        }
        go squareArrayChannel(numbers[start:end], signal)
    }

    for i := 0; i < numCoroutines; i++ {
        <-signal
    }
    fmt.Println(numbers)
}

不同的方法适用于不同的场景，开发者可根据实际需求灵活选择，以实现高效且稳定的并发程序。