Go-同步原语与锁（二）WaitGroup、Once与Cond

本文将讲解一下Go语言中的同步原语与锁。会阐述几种常见的锁，剖析其流程，然后针对每种同步原语举几个例子。由于文章比较长，为方便阅读，将这部分拆解为两部分。本文是第二部分 WaitGroup、Once与Cond。

环境： go version go1.8.7 darwin/amd64

1 WaitGroup

1.1 结构

type WaitGroup struct {
    noCopy noCopy

    // 64-bit value: high 32 bits are counter, low 32 bits are waiter count.
    // 64-bit atomic operations require 64-bit alignment, but 32-bit
    // compilers do not ensure it. So we allocate 12 bytes and then use
    // the aligned 8 bytes in them as state.
    state1 [12]byte
    sema   uint32
}

如源码注释中所说，WaitGroup 就是要等一堆goroutines结束。主routine 利用wg的Add设置一个数量去等待，然后每个routine 执行，执行完调用wg的Done函数。同时，Wait在所有routine没有执行完之前，一直在等待。
其主要的函数就是Add, Done, Wait。

1.2 流程

1.2.1 Add与Done

Add 方法的主要作用就是更新 WaitGroup 中持有的计数器 counter。开始设置的是大于0的数量，当每次调用Done的时候，底层就是调用的Add方法，对计数器进行减一操作。当调用 Add 方法导致计数器归零并且还有等待的 Goroutine 时，就会通过 runtime_Semrelease 唤醒处于等待状态的所有 Goroutine。

1.2.2 Wait

另一个 WaitGroup 的方法 Wait 就会在当前计数器中保存的数据大于 0 时修改等待 Goroutine 的个数 waiter 并调用 runtime_Semacquire 陷入睡眠状态。

1.3 例子

func TestMultiRoutineWaitGroup(t *testing.T) {
    wg := sync.WaitGroup{}
    wgCount := 10
    wg.Add(wgCount)
    for i := 0; i < wgCount; i++ {
        go func(i int) {
            fmt.Println(i, " in processing")
            wg.Done()
            time.Sleep(time.Millisecond * 1000)
            // 在子routine 中也等待所有的routine结束才执行下面的输出。
            wg.Wait()
            fmt.Println("all done, ", i, " ended!")
        }(i)
    }
    wg.Wait()
    time.Sleep(time.Second)
    fmt.Println("all done")
}

结果：

9  in processing
0  in processing
4  in processing
1  in processing
2  in processing
3  in processing
5  in processing
8  in processing
7  in processing
6  in processing
all done,  2  ended!
all done
all done,  7  ended!
all done,  8  ended!
all done,  0  ended!
all done,  3  ended!
all done,  9  ended!
all done,  5  ended!
all done,  4  ended!
all done,  1  ended!
all done,  6  ended!

2 Once

保证在 Go 程序运行期间 Once 对应的某段代码只会执行一次。

2.1 结构

type Once struct {
    m    Mutex
    done uint32
}

其结构里面包含了一个互斥锁。

2.2 流程

其核心流程就是一个Do函数，Do的操作就是先获取互斥锁，获取到了才执行。

func (o *Once) Do(f func()) {
    if atomic.LoadUint32(&o.done) == 1 {
        return
    }
    // Slow-path.
    o.m.Lock()
    defer o.m.Unlock()
    if o.done == 0 {
        defer atomic.StoreUint32(&o.done, 1)
        f()
    }
}

2.3 例子

func TestOnce(t *testing.T) {
    o := &sync.Once{}
    for i := 0; i < 10; i++ {
        go func(i int) {
            fmt.Println("routine： ", i)
            o.Do(func() {
                // 多试几次，发现并不是一定是第0个 routine 执行。
                fmt.Println(i , " dided")
            })
        }(i)
    }
}

结果：

routine：  1
1  dided
routine：  0
routine：  2
routine：  7
routine：  6
routine：  4
routine：  5
routine：  8
routine：  9
routine：  3

3 Cond

Cond 其实是一个条件变量，通过 Cond 可以让一系列的 Goroutine 都在触发某个事件或者条件时才被唤醒，每一个 Cond 结构体都包含一个互斥锁 L

3.1 结构

type Cond struct {
    noCopy noCopy

    // L is held while observing or changing the condition
    L Locker 

    notify  notifyList // 需要被通知的routine
    checker copyChecker
}

3.2 流程

Cond中，有一堆routine处于Wait状态，有些routine处于通知的状态。当处于Wait状态的routine收到通知才能继续执行。

3.2.1 Wait

Wait 方法会将当前 Goroutine 陷入休眠状态，它会先调用 runtime_notifyListAdd 将等待计数器 +1，然后解锁并调用 runtime_notifyListWait 等待其他 Goroutine 的唤醒

3.2.2 Broadcast

Broadcast 会唤醒队列中全部的 routine。

func (c *Cond) Broadcast() {
    c.checker.check()
    runtime_notifyListNotifyAll(&c.notify)
}

3.2.3 Signal

Signal 唤醒队列最前面的 routine。

func (c *Cond) Signal() {
    c.checker.check()
    runtime_notifyListNotifyOne(&c.notify)
}

3.3 例子

func TestCond(t *testing.T) {
    c := sync.NewCond(&sync.Mutex{})
    for i := 0; i < 10; i++ {
        go listen(c, i)
    }
    time.Sleep(1*time.Second)

    // 唤醒等待队列第一个routine ，等待最久的routine
    go signal(c)

    // 唤醒所有
    go broadcast(c)

    time.Sleep(time.Second * 5)

}

func signal(c *sync.Cond) {
    c.L.Lock()
    fmt.Println("before signal===========")
    // 仅仅会唤醒休眠队列前面的routine
    c.Signal()
    fmt.Println("after signal===========")
    c.L.Unlock()
}

func broadcast(c *sync.Cond) {
    c.L.Lock()
    fmt.Println("before broadcast===========")
    // 给所有wait的routine发送信号
    c.Broadcast()
    fmt.Println("after broadcast===========")

    c.L.Unlock()
}

func listen(c *sync.Cond, i int) {
    c.L.Lock()
    // 等待信号
    c.Wait()
    fmt.Println( "listen: ", i)
    c.L.Unlock()
    fmt.Println("after listen: ", i)
}

结果：

before signal===========
after signal===========
before broadcast===========
after broadcast===========
listen:  7
after listen:  7
listen:  9
after listen:  9
listen:  8
after listen:  8
listen:  3
after listen:  3
listen:  4
after listen:  4
listen:  6
after listen:  6
listen:  5
after listen:  5
listen:  2
after listen:  2
listen:  0
after listen:  0
listen:  1
after listen:  1

4 总结

本文是《同步原语与锁》的第二部分-WaitGroup, Once, Cond。从结构、流程、demo 三个维度进行了分析，希望对你有所帮助~

5 参考文献

同步原语与锁 https://draveness.me/golang/concurrency/golang-sync-primitives.html
Go 1.8 源码

6 其他

本文是《循序渐进go语言》的第十四篇-《Go-同步原语与锁（二）WaitGroup、Once与Cond》。
如果有疑问，可以直接留言，也可以关注公众号 “链人成长chainerup” 提问留言，或者加入知识星球“链人成长” 与我深度链接~