sync标准库包中提供的并发同步技术

    通道用例大全一文中介绍了很多通过使用通道来实现并发同步的用例。 事实上，通道并不是Go支持的唯一的一种并发同步技术。而且对于一些特定的情形，通道并不是最有效和可读性最高的同步技术。 本文下面将介绍sync标准库包中提供的各种并发同步技术。相对于通道，这些技术对于某些情形更加适用。

    sync标准库包提供了一些用于实现并发同步的类型。这些类型适用于各种不同的内存顺序需求。 对于这些特定的需求，这些类型使用起来比通道效率更高，代码实现更简洁。

    （请注意：为了避免各种异常行为，最好不要复制sync标准库包中提供的类型的值。）

    每个sync.WaitGroup值在内部维护着一个计数，此计数的初始默认值为零。

    *sync.WaitGroup类型有三个方法：Add(delta int)、Done()和Wait()。

    对于一个可寻址的sync.WaitGroup值wg，

    • 我们可以使用方法调用wg.Add(delta)来改变值wg维护的计数。
    • 方法调用wg.Done()和wg.Add(-1)是完全等价的。
    • 如果一个wg.Add(delta)或者wg.Done()调用将wg维护的计数更改成一个负数，一个恐慌将产生。
    • 当一个协程调用了wg.Wait()时，
      • 如果此时wg维护的计数为零，则此wg.Wait()此操作为一个空操作（no-op）；
      • 否则（计数为一个正整数），此协程将进入阻塞状态。 当以后其它某个协程将此计数更改至0时（一般通过调用wg.Done()），此协程将重新进入运行状态（即wg.Wait()将返回）。

    请注意wg.Add(delta)、wg.Done()和wg.Wait()分别是(&wg).Add(delta)、(&wg).Done()和(&wg).Wait()的简写形式。

    一般，一个sync.WaitGroup值用来让某个协程等待其它若干协程都先完成它们各自的任务。 一个例子：

    在此例中，主协程等待着直到其它5个协程已经将各自负责的元素初始化完毕此会打印出各个元素值。 这里是一个可能的程序执行输出结果：

    1. Done: 4
    2. Done: 1
    3. Done: 3
    4. Done: 0
    5. Done: 2
    6. values: [71 89 50 62 60]

    我们可以将上例中的Add方法调用拆分成多次调用：

    1. ...
    2.     var wg sync.WaitGroup
    3.     for i := 0; i < N; i++ {
    4.         wg.Add(1) // 将被执行5次
    5.         i := i
    6.         go func() {
    7.             values[i] = 50 + rand.Int31n(50)
    8.             wg.Done()
    9.         }()
    10.     }
    11. ...

    一个*sync.WaitGroup值的Wait方法可以在多个协程中调用。 当对应的sync.WaitGroup值维护的计数降为0，这些协程都将得到一个（广播）通知而结束阻塞状态。

    1. func main() {
    2.     rand.Seed(time.Now().UnixNano())
    4.     const N = 5
    5.     var values [N]int32
    7.     var wgA, wgB sync.WaitGroup
    8.     wgA.Add(N)
    9.     wgB.Add(1)
    11.     for i := 0; i < N; i++ {
    12.         i := i
    13.         go func() {
    14.             wgB.Wait() // 等待广播通知
    15.             log.Printf("values[%v]=%v \n", i, values[i])
    16.             wgA.Done()
    17.         }()
    18.     }
    20.     // 下面这个循环保证将在上面的任何一个
    21.     // wg.Wait调用结束之前执行。
    22.     for i := 0; i < N; i++ {
    23.         values[i] = 50 + rand.Int31n(50)
    24.     }
    25.     wgB.Done() // 发出一个广播通知
    26.     wgA.Wait()
    27. }

    一个WaitGroup可以在它的一个Wait方法返回之后被重用。 但是请注意，当一个WaitGroup值维护的基数为零时，它的带有正整数实参的Add方法调用不能和它的Wait方法调用并发运行，否则将可能出现数据竞争。

    每个*sync.Once值有一个Do(f func())方法。 此方法只有一个类型为func()的参数。

    对一个可寻址的sync.Once值o，o.Do()（即(&o).Do()的简写形式）方法调用可以在多个协程中被多次并发地执行， 这些方法调用的实参应该（但并不强制）为同一个函数值。 在这些方法调用中，有且只有一个调用的实参函数（值）将得到调用。 此被调用的实参函数保证在任何o.Do()方法调用返回之前退出。 换句话说，被调用的实参函数内的代码将在任何o.Do()方法返回调用之前被执行。

    一般来说，一个sync.Once值被用来确保一段代码在一个并发程序中被执行且仅被执行一次。

    一个例子：

    在此例中，Hello将仅被输出一次，而world!将被输出5次，并且Hello肯定在所有的5个world!之前输出。

    除了Lock()和Unlock()这两个方法，*sync.RWMutex类型还有两个另外的方法：RLock()和RUnlock()，用来支持多个读取者并发读取一份数据但防止此份数据被某个数据写入者和其它数据访问者（包括读取者和写入者）同时使用。

    （注意：这里的数据读取者和数据写入者不应该从字面上理解。有时候某些数据读取者可能修改数据，而有些数据写入者可能只读取数据。）

    一个Mutex值常称为一个互斥锁。 一个Mutex零值为一个尚未加锁的互斥锁。 一个（可寻址的）Mutex值m只有在未加锁状态时才能通过m.Lock()方法调用被成功加锁。 换句话说，一旦m值被加了锁（亦即某个m.Lock()方法调用成功返回）， 一个新的加锁试图将导致当前协程进入阻塞状态，直到此Mutex值被解锁为止（通过m.Unlock()方法调用）。

    注意：m.Lock()和m.Unlock()分别是(&m).Lock()和(&m).Unlock()的简写形式。

    一个使用sync.Mutex的例子：

    1. package main
    3. import (
    4.     "fmt"
    5.     "runtime"
    7. )
    9. type Counter struct {
    10.     m sync.Mutex
    11.     n uint64
    12. }
    14. func (c *Counter) Value() uint64 {
    15.     c.m.Lock()
    16.     defer c.m.Unlock()
    17.     return c.n
    18. }
    20. func (c *Counter) Increase(delta uint64) {
    21.     c.m.Lock()
    22.     c.n += delta
    23. }
    25. func main() {
    26.     var c Counter
    27.     for i := 0; i < 100; i++ {
    28.         go func() {
    29.             for k := 0; k < 100; k++ {
    30.                 c.Increase(1)
    31.             }
    32.         }()
    33.     }
    35.     // 此循环仅为演示目的。
    36.     for c.Value() < 10000 {
    37.         runtime.Gosched()
    38.     }
    39.     fmt.Println(c.Value()) // 10000
    40. }

    在上面这个例子中，一个Counter值使用了一个Mutex字段来确保它的字段n永远不会被多个协程同时使用。

    一个RWMutex值常称为一个读写互斥锁，它的内部包含两个锁：一个写锁和一个读锁。 对于一个可寻址的RWMutex值rwm，数据写入者可以通过方法调用rwm.Lock()对rwm加写锁，或者通过rwm.RLock()方法调用对rwm加读锁。 方法调用rwm.Unlock()和rwm.RUnlock()用来解开rwm的写锁和读锁。 rwm的读锁维护着一个计数。当rwm.RLock()调用成功时，此计数增1；当rwm.Unlock()调用成功时，此计数减1； 一个零计数表示rwm的读锁处于未加锁状态；反之，一个非零计数（肯定大于零）表示rwm的读锁处于加锁状态。

    注意rwm.Lock()、rwm.Unlock()、rwm.RLock()和rwm.RUnlock()分别是(&rwm).Lock()、(&rwm).Unlock()、(&rwm).RLock()和(&rwm).RUnlock()的简写形式。

    对于一个可寻址的RWMutex值rwm，下列规则存在：

    • rwm的写锁只有在它的写锁和读锁都处于未加锁状态时才能被成功加锁。 换句话说，rwm的写锁在任何时刻最多只能被一个数据写入者成功加锁，并且rwm的写锁和读锁不能同时处于加锁状态。
    • 当rwm的写锁正处于加锁状态的时候，任何新的对之加写锁或者加读锁的操作试图都将导致当前协程进入阻塞状态，直到此写锁被解锁，这样的操作试图才有机会成功。
    • 当rwm的读锁正处于加锁状态的时候，新的加写锁的操作试图将导致当前协程进入阻塞状态。 但是，一个新的加读锁的操作试图将成功，只要此操作试图发生在任何被阻塞的加写锁的操作试图之前（见下一条规则）。 换句话说，一个读写互斥锁的读锁可以同时被多个数据读取者同时加锁而持有。 当rwm的读锁维护的计数清零时，读锁将返回未加锁状态。
    • 假设rwm的读锁正处于加锁状态的时候，为了防止后续数据写入者没有机会成功加写锁，后续发生在某个被阻塞的加写锁操作试图之后的所有加读锁的试图都将被阻塞。
    • 假设rwm的写锁正处于加锁状态的时候，（至少对于标准编译器来说，）为了防止后续数据读取者没有机会成功加读锁，发生在此写锁下一次被解锁之前的所有加读锁的试图都将在此写锁下一次被解锁之后肯定取得成功，即使所有这些加读锁的试图发生在一些仍被阻塞的加写锁的试图之后。

    后两条规则是为了确保数据读取者和写入者都有机会执行它们的操作。

    请注意：一个锁并不会绑定到一个协程上，即一个锁并不记录哪个协程成功地加锁了它。 换句话说，一个锁的加锁者和此锁的解锁者可以不是同一个协程，尽管在实践中这种情况并不多见。

    在上一个例子中，如果Value方法被十分频繁调用而Increase方法并不频繁被调用，则Counter类型的m字段的类型可以更改为sync.RWMutex，从而使得执行效率更高，如下面的代码所示。

    1. ...
    2. type Counter struct {
    3.     //m sync.Mutex
    4.     m sync.RWMutex
    5.     n uint64
    6. }
    8. func (c *Counter) Value() uint64 {
    9.     //c.m.Lock()
    10.     //defer c.m.Unlock()
    11.     c.m.RLock()
    12.     defer c.m.RUnlock()
    13.     return c.n
    14. }
    15. ...

    sync.RWMutex值的另一个应用场景是将一个写任务分隔成若干小的写任务。下一节中展示了一个这样的例子。

    根据上面列出的后两条规则，下面这个程序最有可能输出abdc。

    1. package main
    3. import (
    4.     "fmt"
    5.     "time"
    6.     "sync"
    7. )
    9. func main() {
    10.     var m sync.RWMutex
    11.     go func() {
    12.         m.RLock()
    13.         fmt.Print("a")
    14.         time.Sleep(time.Second)
    15.         m.RUnlock()
    16.     }()
    17.     go func() {
    18.         time.Sleep(time.Second * 1 / 4)
    19.         m.Lock()
    20.         fmt.Print("b")
    21.         time.Sleep(time.Second)
    22.         m.Unlock()
    23.     }()
    24.     go func() {
    25.         time.Sleep(time.Second * 2 / 4)
    26.         m.Lock()
    27.         fmt.Print("c")
    28.         m.Unlock()
    29.     }()
    30.     go func () {
    31.         time.Sleep(time.Second * 3 / 4)
    32.         m.RLock()
    33.         fmt.Print("d")
    34.         m.RUnlock()
    35.     }()
    36.     time.Sleep(time.Second * 3)
    37.     fmt.Println()
    38. }

    请注意，上例这个程序仅仅是为了解释和验证上面列出的读写锁的后两条加锁规则。 此程序使用了time.Sleep调用来做协程间的同步。。

    sync.Mutex和sync.RWMutex值也可以用来实现通知，尽管这不是Go中最优雅的方法来实现通知。 下面是一个使用了值来实现通知的例子。

    在此例中，Hi将确保在Bye之前打印出来。 关于sync.Mutex和sync.RWMutex值相关的内存顺序保证，请阅读Go中的内存顺序保证一文。

    每个sync.Cond值拥有一个sync.Locker类型的名为L的字段。 此字段的具体值常常为一个*sync.Mutex值或者*sync.RWMutex值。

    *sync.Cond类型有三个方法：Wait()、Signal()和Broadcast()。

    每个Cond值维护着一个先进先出等待协程队列。 对于一个可寻址的Cond值c，

    • 一个c.Signal()调用将唤醒并移除c所维护的等待协程队列中的第一个协程（如果此队列不为空的话）。
    • 一个c.Broadcast()调用将唤醒并移除c所维护的等待协程队列中的所有协程（如果此队列不为空的话）。

    请注意：c.Wait()、c.Signal()和c.Broadcast()分别为(&c).Wait()、(&c).Signal()和(&c).Broadcast()的简写形式。

    c.Signal()和c.Broadcast()调用常用来通知某个条件的状态发生了变化。 一般说来，c.Wait()应该在一个检查某个条件是否已经得到满足的循环中调用。

    下面是一个典型的sync.Cond用例。

    1. package main
    3. import (
    4.     "fmt"
    5.     "math/rand"
    6.     "sync"
    7.     "time"
    8. )
    10. func main() {
    11.     rand.Seed(time.Now().UnixNano())
    13.     const N = 10
    14.     var values [N]string
    16.     cond := sync.NewCond(&sync.Mutex{})
    18.     for i := 0; i < N; i++ {
    19.         d := time.Second * time.Duration(rand.Intn(10)) / 10
    20.         go func(i int) {
    21.             time.Sleep(d) // 模拟一个工作负载
    22.             cond.L.Lock()
    23.             // 下面的修改必须在cond.L被锁定的时候执行
    24.             values[i] = string('a' + i)
    25.             cond.Broadcast() // 可以在cond.L被解锁后发出通知
    26.             cond.L.Unlock()
    27.             // 上面的通知也可以在cond.L未锁定的时候发出。
    28.             //cond.Broadcast() // 上面的调用也可以放在这里
    29.         }(i)
    30.     }
    32.     // 此函数必须在cond.L被锁定的时候调用。
    33.     checkCondition := func() bool {
    34.         fmt.Println(values)
    35.         for i := 0; i < N; i++ {
    36.             if values[i] == "" {
    37.                 return false
    38.             }
    39.         }
    40.         return true
    41.     }
    43.     cond.L.Lock()
    44.     defer cond.L.Unlock()
    45.     for !checkCondition() {
    46.         cond.Wait() // 必须在cond.L被锁定的时候调用
    47.     }
    48. }

    一个可能的输出：

    1. [         ]
    2. [     f    ]
    3. [  c   f    ]
    4. [  c   f  h  ]
    5. [ b c   f  h  ]
    6. [a b c   f  h  j]
    7. [a b c   f g h i j]
    8. [a b c  e f g h i j]
    9. [a b c d e f g h i j]

    因为上例中只有一个协程（主协程）在等待通知，所以其中的cond.Broadcast()调用也可以换为cond.Signal()。 如上例中的注释所示，cond.Broadcast()和cond.Signal()不必在cond.L的锁处于加锁状态时调用。

    为了防止数据竞争，对自定义条件的修改必须在cond.L的锁处于加锁状态时才能执行。 另外，checkCondition函数和cond.Wait方法也必须在cond.L的锁处于加锁状态时才可被调用。

    事实上，对于上面这个特定的例子，cond.L字段的也可以为一个*sync.RWMutex值。 对自定义条件的十个部分的修改可以在RWMutex值的读锁处于加锁状态时执行。这十个修改可以并发进行，因为它们是互不干扰的。 如下面的代码所示：

    1. ...
    2.     cond := sync.NewCond(&sync.RWMutex{})
    3.     cond.L.Lock()
    5.     for i := 0; i < N; i++ {
    6.         d := time.Second * time.Duration(rand.Intn(10)) / 10
    7.         go func(i int) {
    8.             time.Sleep(d)
    9.             cond.L.(*sync.RWMutex).RLock()
    10.             values[i] = string('a' + i)
    11.             cond.L.(*sync.RWMutex).RUnlock()
    12.             cond.Signal()
    13.         }(i)
    14.     }

    在上面的代码中，此sync.RWMutex值的用法有些不符常规。 它的读锁被一些修改数组元素的协程所加锁并持有，而它的写锁被主协程加锁持有用来读取并检查各个数组元素的值。

    Cond值所表示的自定义条件可以是一个虚无。对于这种情况，此Cond值纯粹被用来实现通知。 比如，下面这个程序将打印出abc或者bac。

    如果需要，多个sync.Cond值可以共享一个值。但是这种情形在实践中并不多见。