为了学习 Go 通过 channel 实现同步的机制，我写了以下代码来试验：

import (
 "fmt"
 "sync"
)
​
var (
 counter int64
 wg      sync.WaitGroup
)
​
func main() {
 ch := make(chan int64)
​
 wg.Add(2)
​
 go incCounter(ch)
 go incCounter(ch)
 ch <- counter
​
 // wait until two goroutines exit
 wg.Wait()
​
 // expected value is 4
 fmt.Println("Final Counter:", counter)
}
func incCounter(ch chan int64) {
 defer wg.Done()
​
 for count := 0; count < 2; count++ {
 // receive data from channel
 value := <-ch
​
 value++
 counter = value
​
 // send data to channel
 ch <- counter
 }
}

上面的代码很简单，就是有两个 goroutine 共享counter这个变量进行读写操作，counter最终的输出值应该是4。为了避免出现不同步的情况，把counter放入一个无缓冲的 channel 中，通过这个 channel 在两个 goroutine 之间传递counter。

运行之后程序报错：

fatal error: all goroutines are asleep - deadlock!

这意味着所有 goroutine 都被阻塞了，整个程序进入死锁状态，可是为什么？

第一个坑

一开始我是百思不得其解，于是就在 Stack Overflow 上求助，有位哥们一语道破天机。他解释道，上面这段程序的执行流程是这样的：

deadlock.jpg

原来是没有 goroutine 在最后从 channel 中取出counter，而这又是个无缓冲的 channel，所有 goroutine 都被阻塞了，自然也就死锁了。

解决方法

很简单，在main中把fmt.Println("Final Counter:", counter)修改为：

fmt.Println("Final Counter:", <-ch)

也就是让主 goroutine 负责取出最终的counter。

第二个坑

本来以为这样就行了，没想到运行之后还是死锁。我 debug 了很久之后终于找出了第二个坑。

程序中使用了sync.WaitGroup这个类型来阻止主 goroutine 在其他子 goroutine 之前终止，也就是不让main函数提前退出。wg.Add(2)就是告诉main要等两个 goroutine 终止之后才能退出，而在 goroutine 中则是通过wg.Done()来通知main函数某个 goroutine 已终止。

wg.Done()前面加上了一个defer，也就是要等到incCounter中其他代码都执行完了才会调用wg.Done()。这就是问题所在，像上面那张图展示的那样，goroutine 2 把counter放入 channel 中，等着主 goroutine 取出；但在main函数中， fmt.Println("Final Counter:", <-ch)之前有一句wg.Wait()，也就是说要等wg.Wait()方法退出了才能执行下一句。然而此时这个方法并没有退出，因为 goroutine 2 还在被ch <- counter阻塞中，也就没法退出循环体，那么也就没法执行wg.Done()！程序也就又死锁了。

解决

必须手动调用wg.Done()而不能依赖defer的延迟调用机制：

func incCounter(ch chan int64) {
 for count := 0; count < 2; count++ {
 // receive data from channel
 value := <-ch
​
 value++
 counter = value
​
 // if this goroutine has incremented counter twice,
 // it will exit
 if count == 1 {
 wg.Done()
 }
​
 // send data to channel
 ch <- counter
 }
}

至此，程序终于可以正常运行，counter最后的输出为4，两个 goroutine 实现了同步。