Go协程同步：通道与WaitGroup使用技巧

本篇文章给大家分享《Go协程同步指南：通道与WaitGroup正确用法》，覆盖了Golang的常见基础知识，其实一个语言的全部知识点一篇文章是不可能说完的，但希望通过这些问题，让读者对自己的掌握程度有一定的认识(B 数)，从而弥补自己的不足，更好的掌握它。

本文详解Go并发编程中goroutine同步的核心机制，对比通道（channel）与sync.WaitGroup两种主流方案，指出无同步导致竞态的原理，并提供可落地的生产级示例代码。

在Go语言中，“线程同步”实际对应的是goroutine间的协调与等待机制——因为Go运行时调度的是轻量级goroutine而非操作系统线程，真正的同步目标是确保多个goroutine对共享状态（如通道中的值）的操作按预期顺序完成，避免主函数过早退出或数据竞争。

你提供的第一个示例使用done chan bool实现同步，逻辑上是可行的，但存在一个关键缺陷：原代码中Goroutine2被调用时漏传了done参数（已由答案指出会引发编译错误或运行时panic），修正后如下：

func Goroutine1(i_chan chan int, done chan bool) {
    for x := 0; x < 1000000; x++ {
        i := <-i_chan
        i++
        i_chan <- i
    }
    done <- true // 通知完成
}

func Goroutine2(i_chan chan int, done chan bool) {
    for x := 0; x < 1000000; x++ {
        i := <-i_chan
        i--
        i_chan <- i
    }
    done <- true // 通知完成
}

func main() {
    i_chan := make(chan int, 1)
    done := make(chan bool, 2) // 缓冲容量为2，避免阻塞
    i_chan <- 0

    go Goroutine1(i_chan, done)
    go Goroutine2(i_chan, done)

    <-done // 等待Goroutine1结束
    <-done // 等待Goroutine2结束
    fmt.Printf("This is the value of i: %d\n", <-i_chan) // 输出应为0
}

该方案利用带缓冲的done通道接收完成信号，主goroutine通过两次接收阻塞等待，从而保证两个工作goroutine执行完毕后再读取最终结果。但此方式存在明显局限：耦合度高、扩展性差（每新增goroutine需手动增减接收语句）、无法传递错误信息。

而第二个“无同步”版本依赖time.Sleep，本质是竞态（race condition）的伪修复：

func main() {
    i_chan := make(chan int, 1)
    i_chan <- 0
    go Goroutine1(i_chan)
    go Goroutine2(i_chan)
    time.Sleep(100 * time.Millisecond) // ❌ 不可靠！
    fmt.Printf("This is the value of i: %d\n", <-i_chan)
}

Sleep无法保证goroutine真正执行完成——它仅暂停主goroutine一段固定时间，而实际执行耗时受CPU负载、调度延迟、GC暂停等多因素影响。即使在本地测试中1秒“刚好够用”，在CI环境或高负载服务器上仍可能失败。更重要的是，Sleep完全违背了Go“通过通信共享内存”的设计哲学，属于反模式。

✅ 推荐方案：使用 sync.WaitGroup
这是Go标准库提供的专用于等待一组goroutine完成的同步原语，语义清晰、零竞态风险、易于扩展：

package main

import (
    "fmt"
    "sync"
    "runtime"
)

func Goroutine1(i_chan chan int, wg *sync.WaitGroup) {
    defer wg.Done() // 标记当前goroutine完成
    for x := 0; x < 1000000; x++ {
        i := <-i_chan
        i++
        i_chan <- i
    }
}

func Goroutine2(i_chan chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for x := 0; x < 1000000; x++ {
        i := <-i_chan
        i--
        i_chan <- i
    }
}

func main() {
    i_chan := make(chan int, 1)
    i_chan <- 0

    var wg sync.WaitGroup
    wg.Add(2) // 预期启动2个goroutine

    go Goroutine1(i_chan, &wg)
    go Goroutine2(i_chan, &wg)

    wg.Wait() // 阻塞直到所有Add的goroutine调用Done()
    fmt.Printf("This is the value of i: %d\n", <-i_chan)
}

WaitGroup的核心方法：

• Add(n)：增加待等待的goroutine计数；
• Done()：递减计数（通常用defer确保执行）；
• Wait()：阻塞直到计数归零。

⚠️ 注意事项：

• WaitGroup不能拷贝传递，必须传指针；
• Add()应在goroutine启动前调用，避免竞态；
• Done()必须与Add()配对，否则Wait()永不返回或panic；
• 对于更复杂的协调需求（如条件等待、超时控制），可结合sync.Cond或context.WithTimeout。

总结：Go中goroutine同步不是“锁住线程”，而是精确表达协作意图。优先选用sync.WaitGroup处理“等待完成”场景；用channel传递数据与控制流；避免Sleep等不精确手段。正确的同步设计，是写出健壮、可维护并发程序的第一步。

以上就是《Go协程同步：通道与WaitGroup使用技巧》的详细内容，更多关于的资料请关注golang学习网公众号！