Golang并发同步详解：WaitGroup使用指南

WaitGroup用于等待一组goroutine完成。其核心是通过Add()增加计数器，Done()减少计数器（等价于Add(-1)），Wait()阻塞主goroutine直到计数器归零。使用时应在启动goroutine前调用Add()，并在每个goroutine中使用defer wg.Done()确保计数器正确减少。避免错误的方法包括：使用defer确保Done()调用、通过指针传递WaitGroup、借助工具审查代码。与channel相比，WaitGroup适用于仅需等待完成而无需数据传递的场景，channel则适合需要数据传输或复杂同步的情况。结合context可控制goroutine生命周期，如通过context.WithCancel()实现优雅退出。

WaitGroup用于等待一组goroutine完成。你可以理解为一个计数器，每启动一个goroutine，计数器加一，goroutine执行完毕，计数器减一。主goroutine调用Wait()方法阻塞，直到计数器变为零。

解决方案：

在Golang中使用WaitGroup非常简单，主要涉及三个方法：Add(), Done(), 和 Wait()。

1. Add(delta int)：增加WaitGroup的计数器。通常在启动goroutine之前调用。delta可以是正数也可以是负数，但通常是正数，表示新增的goroutine数量。
2. Done()：减少WaitGroup的计数器。在goroutine执行完毕后调用。相当于Add(-1)。
3. Wait()：阻塞调用它的goroutine（通常是主goroutine），直到WaitGroup的计数器变为零。

下面是一个简单的例子：

package main

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

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // 确保goroutine退出时计数器减一
    fmt.Printf("Worker %d starting\n", id)
    time.Sleep(time.Second) // 模拟耗时操作
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 3; i++ {
        wg.Add(1) // 启动一个goroutine，计数器加一
        go worker(i, &wg)
    }

    wg.Wait() // 阻塞直到所有goroutine完成
    fmt.Println("All workers done")
}

这个例子创建了三个worker goroutine，每个goroutine休眠一秒后退出。主goroutine等待所有worker goroutine完成后才退出。

WaitGroup的零值是有效的，意味着你可以直接声明一个sync.WaitGroup类型的变量，而不需要进行初始化。

WaitGroup的计数器不能为负数。如果计数器变为负数，会panic。因此，确保Add()的调用次数与Done()的调用次数匹配。

如何避免WaitGroup使用中的常见错误？

使用WaitGroup时，最常见的错误包括：

• 忘记Done()：如果goroutine忘记调用Done()，WaitGroup将永远不会变为零，导致Wait()永久阻塞。
• Done()调用次数过多：如果Done()的调用次数超过Add()的调用次数，会导致panic。
• Add()和goroutine启动顺序问题：如果Add()在goroutine启动之后调用，可能导致WaitGroup计数器不准确。应该始终在启动goroutine之前调用Add()。
• WaitGroup传递问题：WaitGroup应该通过指针传递，而不是值传递。值传递会导致每个goroutine都操作的是WaitGroup的副本，而不是同一个WaitGroup。

为了避免这些错误，可以考虑使用defer语句来确保Done()被调用，并且仔细检查Add()和Done()的调用次数是否匹配。同时，使用代码审查工具可以帮助发现潜在的错误。

WaitGroup和channel有什么区别？何时使用哪个？

WaitGroup和channel都是用于goroutine同步的机制，但它们的使用场景有所不同。

• WaitGroup主要用于等待一组goroutine完成。它不涉及数据的传递，只关注goroutine的完成状态。
• Channel主要用于goroutine之间的数据传递和同步。它可以用于等待单个或多个goroutine，也可以用于在goroutine之间传递数据。

通常情况下，如果只需要等待一组goroutine完成，而不需要传递数据，那么WaitGroup是更简单和高效的选择。如果需要在goroutine之间传递数据，或者需要更复杂的同步逻辑，那么channel是更好的选择。

例如，可以使用channel来收集多个goroutine的结果，或者使用channel来实现一个工作池。

package main

import (
    "fmt"
    "sync"
)

func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    for j := range jobs {
        fmt.Printf("Worker %d processing job %d\n", id, j)
        results <- j * 2
    }
}

func main() {
    numJobs := 5
    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)
    var wg sync.WaitGroup

    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go worker(i, jobs, results, &wg)
    }

    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    wg.Wait()
    close(results)

    for a := range results {
        fmt.Println(a)
    }
}

这个例子使用了channel来传递任务和结果，同时使用WaitGroup来等待所有worker goroutine完成。

如何使用context控制goroutine的生命周期？

Context可以用于控制goroutine的生命周期，例如取消goroutine的执行。结合WaitGroup和context，可以实现更复杂的goroutine管理。

可以使用context.WithCancel()创建一个可取消的context。当调用cancel()函数时，所有监听该context的goroutine都会收到取消信号。

package main

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

func worker(ctx context.Context, id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d starting\n", id)
    defer fmt.Printf("Worker %d done\n", id)

    for {
        select {
        case <-ctx.Done():
            fmt.Printf("Worker %d cancelled\n", id)
            return
        default:
            fmt.Printf("Worker %d working\n", id)
            time.Sleep(time.Millisecond * 500)
        }
    }
}

func main() {
    var wg sync.WaitGroup
    ctx, cancel := context.WithCancel(context.Background())

    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go worker(ctx, i, &wg)
    }

    time.Sleep(time.Second * 2)
    fmt.Println("Cancelling context")
    cancel()

    wg.Wait()
    fmt.Println("All workers done")
}

这个例子创建了三个worker goroutine，每个goroutine会循环执行，直到收到取消信号。主goroutine在2秒后取消context，导致所有worker goroutine退出。WaitGroup用于等待所有worker goroutine退出。

使用context可以更优雅地控制goroutine的生命周期，避免资源泄漏和死锁。