Go语言并发编程-同步和锁

同步和锁

概述

同步是并发编程的基本要素之一，我们通过channel可以完成多个goroutine间数据和信号的同步。

除了channel外，我们还可以使用go的官方同步包sync，sync/atomic 完成一些基础的同步功能。主要包含同步数据、锁、原子操作等。

一个同步失败的示例：

 func SyncErr() {
     wg := sync.WaitGroup{}
     // 计数器
     counter := 0
     // 多个goroutine并发的累加计数器
     gs := 100
     wg.Add(gs)
     for i := 0; i < gs; i++ {
         go func() {
             defer wg.Done()
             // 累加
             for k := 0; k < 100; k++ {
                 counter++
                 // ++ 操作不是原子的
                 // counter = counter + 1
                 // 1. 获取当前的counter变量
                 // 2. +1
                 // 3. 赋值新值到counter
             }
         }()
     }
     // 统计计数结果
     wg.Wait()
     fmt.Println("Counter:", counter)
 }

Lock解决方案：

 func SyncLock() {
     n := 0
     wg := sync.WaitGroup{}
 ​
     lk := sync.Mutex{}
     for i := 0; i < 1000; i++ {
         wg.Add(1)
         go func() {
             defer wg.Done()
             for i := 0; i < 100; i++ {
                 lk.Lock()
                 n++
                 lk.Unlock()
             }
         }()
     }
     wg.Wait()
     fmt.Println("n:", n)
 }
 ​
 // run
 n: 100000

互斥锁Mutex的使用

sync包提供了两种锁：

• 互斥锁，Mutex

• 读写互斥锁，RWMutex

互斥锁，同一时刻只能有一个goroutine申请锁定成功，不区分读、写操作。也称为：独占锁、排它锁。

提供了如下方法完成锁操作：

 type Mutex
 // 锁定锁m, 若锁m已是锁定状态，调用的goroutine会被阻塞，直到可以锁定
 func (m *Mutex) Lock()
 // 解锁锁m，若m不是锁定状态，会导致运行时错误
 func (m *Mutex) Unlock()
 // 尝试是否可以加锁，返回是否成功
 func (m *Mutex) TryLock() bool

注意：锁与goroutine没有关联，意味着允许一个goroutine加锁，在另一个goroutine中解锁。但是不是最典型的用法。

典型的锁用法：

 var lck sync.Mutex
 func () {
     lck.Lock()
     // 互斥执行的代码
     defer lck.Unlock()
 }

锁的流程：

示例：

 func SyncMutex() {
     wg := sync.WaitGroup{}
     var lck sync.Mutex
     for i := 0; i < 4; i++ {
         wg.Add(1)
         go func(n int) {
             defer wg.Done()
             fmt.Println("before lock: ", n)
             lck.Lock()
             fmt.Println("locked: ", n)
             time.Sleep(1 * time.Second)
             lck.Unlock()
             fmt.Println("after lock: ", n)
         }(i)
     }
     wg.Wait()
 }

某次输出结果：

 before lock:  3
 locked:  3   
 before lock:  2
 before lock:  1
 before lock:  0
 after lock:  3
 locked:  2
 after lock:  2
 locked:  1
 after lock:  1
 locked:  0
 after lock:  0

可以发现，before lock 都是先执行的，而Lock() 操作，必须要等到其他goroutineUnlock()才能成功。

注意，如果其他goroutine没有通过相同的锁（1没用锁，2用了其他锁）去操作资源，那么是不受锁限制的，例如：

 func SyncLockAndNo() {
     n := 0
     wg := sync.WaitGroup{}
     lk := sync.Mutex{}
     for i := 0; i < 1000; i++ {
         wg.Add(1)
         go func() {
             defer wg.Done()
             for i := 0; i < 100; i++ {
                 lk.Lock()
                 n++
                 lk.Unlock()
             }
         }()
     }
     wg.Add(1)
     go func() {
         defer wg.Done()
         for i := 0; i < 10000; i++ {
             n++
         }
     }()
 ​
     // 其他锁
     //var lk2 sync.Mutex
     //go func() {
     //    defer wg.Done()
     //    for i := 0; i < 10000; i++ {
     //        lk2.Lock()
     //        n++
     //        lk2.Unlock()
     //    }
     //}()
 ​
     wg.Wait()
     fmt.Println("n:", n)
 }
 ​
 // 其中一次结果
 n: 109876

我们在第一个counter的例子上，增加了一个goroutine同去累加计数器counter，但没有使用前面的Mutex（不使用或使其他锁）。可见，出现了资源争用的情况。因此要注意：如果要限制资源的并发争用，要全部的资源操作都使用同一个锁。

实操时，锁除了直接调用外，还经常性出现在结构体中，以某个字段的形式出现，用于包含struct字段不会被多gorutine同时修改，例如我们 cancelCtx：

 type cancelCtx struct {
     Context
 ​
     mu       sync.Mutex            // protects following fields
     done     atomic.Value          // of chan struct{}, created lazily, closed by first cancel call
     children map[canceler]struct{} // set to nil by the first cancel call
     err      error                 // set to non-nil by the first cancel call
 }

我们通常也会这么做，示例：

 type Post struct {
     Subject string
     // 赞
     Likes   int
     // 操作锁定
     mu sync.Mutex
 }
 ​
 func (p *Post) IncrLikes() *Post {
     p.mu.Lock()
     defer p.mu.Unlock()
     p.Likes++
 ​
     return p
 }
 ​
 func (p *Post) DecrLikes() *Post {
     p.mu.Lock()
     defer p.mu.Unlock()
     p.Likes--
 ​
     return p
 }

读写RWMutex的使用

读写互斥锁，将锁操作类型做了区分，分为读锁和写锁，由sync.RWMutex类型实现：

• 读锁，Read Lock，共享读，阻塞写

• 写锁，Lock，独占操作，阻塞读写

并发	读	写
读	支持	不支持
写	不支持	不支持

之所以减小锁的粒度，因为实际操作中读操作的比例要远高于写操作的比例，增加了共享读操作锁后，可以更大程度的提升读的并发能力。

sync.RWMutex 提供了如下方法完成操作：

 type RWMutex
 // 写锁定
 func (rw *RWMutex) Lock()
 // 写解锁
 func (rw *RWMutex) Unlock()
 ​
 // 读锁定
 func (rw *RWMutex) RLock()
 // 读解锁
 func (rw *RWMutex) RUnlock()
 ​
 // 尝试加写锁定
 func (rw *RWMutex) TryLock() bool
 // 尝试加读锁定
 func (rw *RWMutex) TryRLock() bool

写锁定，与互斥锁Mutex的语法和操作结果一致，都是保证互斥的独占操作。

读锁定，可以在已经存在读锁的情况下，加锁成功。

如图所示：

读锁示例：

 func SyncRLock() {
     wg := sync.WaitGroup{}
     // 模拟多个goroutine
     var rwlck sync.RWMutex
     for i := 0; i < 10; i++ {
         wg.Add(1)
         go func() {
             defer wg.Done()
             //
             //rwlck.Lock()
             rwlck.RLock()
             // 输出一段内容
             fmt.Println(time.Now())
             time.Sleep(1 * time.Second)
             //
             //rwlck.Unlock()
             rwlck.RUnlock()
         }()
     }
 ​
     wg.Add(1)
     go func() {
         defer wg.Done()
         //
         rwlck.Lock()
         //rwlck.RLock()
         // 输出一段内容
         fmt.Println(time.Now(), "Lock")
         time.Sleep(1 * time.Second)
         //
         rwlck.Unlock()
         //rwlck.RUnlock()
     }()
 ​
     wg.Wait()
 }

其中，使用读锁，输出操作会全部立即执行，然后集体sleep1s后全部结束。使用写锁，输出和Sleep会间隔1s依次执行。

实操示例：

 type Article struct {
     Subject string
     // 赞
     likes int
     // 操作锁定
     mu sync.RWMutex
 }
 ​
 func (a Article) Likes() int {
     a.mu.RLock()
     defer a.mu.RUnlock()
     return a.likes
 }
 ​
 func (a *Article) IncrLikes() *Article {
     a.mu.Lock()
     defer a.mu.Unlock()
     a.likes++
     return a
 }

同步Map sync.Map

Go中Map是非线程（goroutine）安全的。并发操作 Map 类型时，会导致 fatal error: concurrent map read and map write错误：

 func SyncMapErr() {
     m := map[string]int{}
     // 并发map写
     go func() {
         for {
             m["key"] = 0
         }
     }()
     // 并发map读
     go func() {
         for {
             _ = m["key"]
         }
     }()
     // 阻塞
     select {}
 }

之所以Go不支持Map的并发安全，是因为Go认为Map的典型使用场景不需要在多个Goroutine间并发安全操作Map。

并发安全操作Map的方案：

• 锁 + Map，自定义Map操作，增加锁的控制，可以选择 Mutex和RWMutex。

• sync.Map，sync包提供的安全Map.

锁+Map示例，在结构体内嵌入sync.Mutex：

 func SyncMapLock() {
     myMap := struct {
         sync.RWMutex
         Data map[string]int
     }{
         Data: map[string]int{},
     }
 ​
     // write
     myMap.Lock()
     myMap.Data["key"] = 0
     myMap.Unlock()
 ​
     // read
     myMap.RLock()
     _ = myMap.Data["key"]
     myMap.RUnlock()
 }

sync.Map 的使用

 type Map
 // 最常用的4个方法：
 // 存储
 func (m *Map) Store(key, value any)
 // 遍历 map
 func (m *Map) Range(f func(key, value any) bool)
 // 删除某个key元素
 func (m *Map) Delete(key any)
 // 返回key的值。存在key，返回value，true，不存在返回 nil, false
 func (m *Map) Load(key any) (value any, ok bool)
 ​
 // 若m[key]==old，执行删除。key不存在，返回false
 func (m *Map) CompareAndDelete(key, old any) (deleted bool)
 // 若m[key]==old，执行交换, m[key] = new
 func (m *Map) CompareAndSwap(key, old, new any) bool
 ​
 // 返回值后删除元素。loaded 表示是否load成功，key不存在，loaded为false
 func (m *Map) LoadAndDelete(key any) (value any, loaded bool)
 // 加载，若加载失败则存储。返回加载或存储的值和是否加载
 func (m *Map) LoadOrStore(key, value any) (actual any, loaded bool)
 ​
 // 存储新值，返回之前的值。loaded表示key是否存在
 func (m *Map) Swap(key, value any) (previous any, loaded bool)

sync.Map 不需要类型初始化，即可使用，可以理解为map[comparable]any。

使用示例，不会触发 fatal error: concurrent map read and map write：

 func SyncSyncMap() {
     var m sync.Map
     go func() {
         for {
             m.Store("key", 0)
         }
     }()
     go func() {
         for {
             _, _ = m.Load("key")
         }
     }()
     select {}
 }

使用示例：

 func SyncSyncMapMethod() {
     wg := sync.WaitGroup{}
     var m sync.Map
     for i := 0; i < 10; i++ {
         wg.Add(1)
         go func(n int) {
             defer wg.Done()
             m.Store(n, fmt.Sprintf("value: %d", n))
         }(i)
     }
 ​
     for i := 0; i < 10; i++ {
         wg.Add(1)
         go func(n int) {
             defer wg.Done()
             fmt.Println(m.Load(n))
         }(i)
     }
 ​
     wg.Wait()
     m.Range(func(key, value any) bool {
         fmt.Println(key, value)
         return true
     })
 ​
     //
     m.Delete(4)
 }

并发安全操作Map的方案的选择，统计的压测数据显示，相对而言：

• 锁 + Map，写快，读慢

• sync.Map，读快，写慢，删快，适合读多写少的场景

原子操作 sync/atomic

原子操作即是进行过程中不能被中断的操作，针对某个值的原子操作在被进行的过程中，CPU绝不会再去进行其他的针对该值的操作。为了实现这样的严谨性，原子操作仅会由一个独立的CPU指令代表和完成。原子操作是无锁的，常常直接通过CPU指令直接实现。 事实上，其它同步技术的实现常常依赖于原子操作。

原子操作是CPU指令级别实现的，比如在Intel的CPU上主要是使用总线锁的方式，AMD的CPU架构机器上就是使用MESI一致性协议的方式来保证原子操作。

go中 sync/atomic 包提供了原子操作的支持，用于同步操作整型（和指针类型）：

• int32

• int64

• uint32

• uint64

• uintptr

• unsafe.Pointer

针对于以上类型，提供了如下操作：

 // Type 是以上的类型之一
 // 比较相等后交换 CAS
 func CompareAndSwapType(addr *Type, old, new Type) (swapped bool)
 // 交换
 func SwapType(addr *Type, new Type) (old Type)
 // 累加
 func AddType(addr *Type, delta Type) (new Type)
 // 获取
 func LoadType(addr *Type) (val Type)
 // 存储
 func StoreType(addr *Type, val Type)

除了以上函数，还提供了对应的类型方法操作，以Int32为例：

 type Int32
 func (x *Int32) Add(delta int32) (new int32)
 func (x *Int32) CompareAndSwap(old, new int32) (swapped bool)
 func (x *Int32) Load() int32
 func (x *Int32) Store(val int32)
 func (x *Int32) Swap(new int32) (old int32)

除了以上几个整型，bool类型也提供了类型上的原子操作：

 type Bool
 func (x *Bool) CompareAndSwap(old, new bool) (swapped bool)
 func (x *Bool) Load() bool
 func (x *Bool) Store(val bool)
 func (x *Bool) Swap(new bool) (old bool)

示例：

 func SyncAtomicAdd() {
     // 并发的过程，没有加锁，Lock
     //var counter int32 = 0
     // type
     // atomic 原子的Int32, counter := 0
     counter := atomic.Int32{}
     wg := sync.WaitGroup{}
     for i := 0; i < 1000; i++ {
         wg.Add(1)
         go func() {
             defer wg.Done()
             for i := 0; i < 100; i++ {
                 //atomic.AddInt32(&counter, 1)
                 // type
                 // 原子累加操作 ， counter ++
                 counter.Add(1)
             }
         }()
     }
     wg.Wait()
     //fmt.Println("counter:", atomic.LoadInt32(&counter))
     // type
     fmt.Println("counter:", counter.Load())
 }

以上示例不会出现不到10000的情况了。

除了预定义的整型的支持，还可以使用 atomic.Value 类型，完成其他类型的原子操作：

 type Value
 func (v *Value) CompareAndSwap(old, new any) (swapped bool)
 func (v *Value) Load() (val any)
 func (v *Value) Store(val any)
 func (v *Value) Swap(new any) (old any)

使用方法：

 func SyncAtomicValue() {
 ​
     var loadConfig = func() map[string]string {
         return map[string]string{
             // some config
             "title":   "马士兵Go并发编程",
             "varConf": fmt.Sprintf("%d", rand.Int63()),
         }
     }
 ​
     var config atomic.Value
 ​
     // 每N秒加载一次配置文件
     go func() {
         for {
             config.Store(loadConfig())
             fmt.Println("latest config was loaded", time.Now().Format("15:04:05.99999999"))
             time.Sleep(time.Second)
         }
     }()
 ​
     // 使用配置
     // 不能在加载的过程中使用配置
     for {
         go func() {
             c := config.Load()
             fmt.Println(c, time.Now().Format("15:04:05.99999999"))
         }()
 ​
         time.Sleep(400 * time.Millisecond)
     }
 ​
     select {}
 }

sync.Pool 并发安全池

池是一组可以单独保存和检索的可以复用的临时对象。存储在池中的任何项目可随时自动删除，无需通知。一个池可以安全地同时被多个goroutine使用。

典型特征：

• sync.Pool 是并发安全的

• 池中的对象由Go负责删除，内存由Go自己回收

• 池中元素的数量由Go负责管理，用户无法干预

• 池中元素应该是临时的，不应该是持久的。例如长连接不适合放入 sync.Pool 中

池的目的是缓存已分配但未使用的项目以供以后重用，从而减轻垃圾收集器的压力。也就是说，它使构建高效、线程安全的自由元素变得容易。

池的一个适当用途是管理一组临时项，这些临时项在包的并发独立客户端之间默默共享，并可能被其重用。池提供了一种在许多客户机上分摊分配开销的方法。

一个很好地使用池的例子是fmt包，它维护了临时输出缓冲区的动态大小存储。

池由 sync.Pool类型实现，具体三个操作：

• 初始化Pool实例，需要提供池中缓存元素的New方法。

• 申请元素，func (p *Pool) Get() any

• 交回对象，func (p *Pool) Put(x any)

操作示例：

 func SyncPool() {
     // 原子的计数器
     var counter int32 = 0
 ​
     // 定义元素的Newer，创建器
     elementNewer := func() any {
         // 原子的计数器累加
         atomic.AddInt32(&counter, 1)
 ​
         // 池中元素推荐（强烈）是指针类型
         return new(bytes.Buffer)
     }
 ​
     // Pool的初始化
     pool := sync.Pool{
         New: elementNewer,
     }
 ​
     // 并发的申请和交回元素
     workerNum := 1024 * 1024
     wg := sync.WaitGroup{}
     wg.Add(workerNum)
     for i := 0; i < workerNum; i++ {
         go func() {
             defer wg.Done()
             // 申请元素，通常需要断言为特定类型
             buffer := pool.Get().(*bytes.Buffer)
             // 不用Pool
             //buffer := elementNewer().(*bytes.Buffer)
             // 交回元素
             defer pool.Put(buffer)
             // 使用元素
             _ = buffer.String()
         }()
     }
 ​
     //
     wg.Wait()
 ​
     // 测试创建元素的次数
     fmt.Println("elements number is :", counter)
 }
 ​
 // elements number is : 12

测试的时候，大家可以发现创建的元素数量远远低于goroutine的数量。

DATA RACE 现象

当程序运行时，由于并发的原因会导致数据竞争使用，有时在编写代码时很难发现，要经过大量测试才会发现。可以用 go run -race ，增加-race选项，检测运行时可能出现的竞争问题。

测试之前的计数器累加代码：本例子需要 main.main 来演示，因为是 go run:

package main

import (
    "fmt"
    "sync"
)

func main() {
    wg := sync.WaitGroup{}
    // 计数器
    counter := 0
    // 多个goroutine并发的累加计数器
    gs := 1000
    wg.Add(gs)
    for i := 0; i < gs; i++ {
        go func() {
            defer wg.Done()
            // 累加
            for k := 0; k < 100; k++ {
                counter++
                // ++ 操作不是原子的
                // counter = counter + 1
                // 1. 获取当前的counter变量
                // 2. +1
                // 3. 赋值新值到counter
            }
        }()
    }
    // 统计计数结果
    wg.Wait()
    fmt.Println("Counter:", counter)
}

结果：

# 没有使用 -race
PS D:\apps\goExample\concurrency> go run .\syncRace.go
n: 94077

# 使用 -race
PS D:\apps\goExample\concurrency> go run -race .\syncRace.go
==================
WARNING: DATA RACE  
Read at 0x00c00000e0f8 by goroutine 9:
  main.main.func1()
      D:/apps/goExample/concurrency/syncMain.go:16 +0xa8

Previous write at 0x00c00000e0f8 by goroutine 7:
Goroutine 9 (running) created at:
  main.main()
      D:/apps/goExample/concurrency/syncMain.go:13 +0x84

Goroutine 7 (finished) created at:
  main.main()
      D:/apps/goExample/concurrency/syncMain.go:13 +0x84
==================
n: 98807
Found 1 data race(s)
exit status 66

该选项用于在开发阶段，检测数据竞争情况。

出现 data race情况，可以使用锁，或原子操作的来解决。

sync.Once

若需要保证多个并发goroutine中，某段代码仅仅执行一次，就可以使用 sync.Once 结构实现。

例如，在获取配置的时候，往往仅仅需要获取一次，然后去使用。在多个goroutine并发时，要保证能够获取到配置，同时仅获取一次配置，就可以使用sync.Once结构：

func SyncOnce() {

    // 初始化config变量
    config := make(map[string]string)

    // 1. 初始化 sync.Once
    once := sync.Once{}

    // 加载配置的函数
    loadConfig := func() {
        // 2. 利用 once.Do() 来执行
        once.Do(func() {
            // 保证执行一次
            config = map[string]string{
                "varInt": fmt.Sprintf("%d", rand.Int31()),
            }
            fmt.Println("config loaded")
        })
    }

    // 模拟多个goroutine，多次调用加载配置
    // 测试加载配置操作，执行了几次
    workers := 10
    wg := sync.WaitGroup{}
    wg.Add(workers)
    for i := 0; i < workers; i++ {
        go func() {
            defer wg.Done()
            // 并发的多次加载配置
            loadConfig()
            // 使用配置
            _ = config

        }()
    }
    wg.Wait()
}

核心逻辑：

1. 初始化 sync.Once

2. once.Do(func()) 可以确保func()仅仅执行一次

sync.Once 的实现很简单：

type Once struct {
    // 是否已处理，保证一次
    done uint32
    // 锁，保证并发安全
    m    Mutex
}

sync.Cond

sync.Cond是sync包提供的基于条件（Condition）的通知结构。

该结构提供了4个方法：

// 创建Cond
func NewCond(l Locker) *Cond
// 全部唤醒
func (c *Cond) Broadcast()
// 唤醒1个
func (c *Cond) Signal()
// 等待唤醒
func (c *Cond) Wait()

其中，创建时，需要1个Locker作为参数，通常是 sync.Mutext或sync.RWMutex。然后两个方法用来通知，一个方法用来等待。

使用逻辑很简单，通常是一个goroutine负责通知，多个goroutine等待处理，如图：

创建Cond，sync.NewCond() 需要提供锁，同时在等待操作和广播（信号）操作中，通常需要先申请锁，其中等待操作是必须的，而官博（信号）操作是可选的。，例如：

cond := sync.NewCond(&sync.Mutex{})
cond := sync.NewCond(&sync.RWMutex{})

还有，cond的广播和信号通知操作是并发安全的，可以重复调用的。

要注意Wait()操作，是会先解锁，等到广播信号后，再加锁。因此，Wait()操作前，要加锁。

示例代码：

• 一个goroutine负责接收数据，完毕后，广播给处理数据的goroutine

• 多个goroutine处理数据，在数据未处理完前，等待广播信号。信号来了，处理数据

func SyncCond() {
    wg := sync.WaitGroup{}
    dataCap := 1024 * 1024
    var data []int
    cond := sync.NewCond(&sync.Mutex{})
    for i := 0; i < 8; i++ {
        wg.Add(1)
        go func(c *sync.Cond) {
            defer wg.Done()
            c.L.Lock()
            for len(data) < dataCap {
                c.Wait()
            }
            fmt.Println("listen", len(data), time.Now())
            c.L.Unlock()
        }(cond)
    }

    wg.Add(1)
    go func(c *sync.Cond) {
        defer wg.Done()
        c.L.Lock()
        defer c.L.Unlock()
        for i := 0; i < dataCap; i++ {
            data = append(data, i*i)
        }
        fmt.Println("Broadcast")
        c.Broadcast()
        //c.Signal()
    }(cond)

    // 为什么 for { wait() }
    // 另外的广播goroutine
    //wg.Add(1)
    //go func(c *sync.Cond) {
    //    defer wg.Done()
    //    c.Broadcast()
    //}(cond)

    wg.Wait()
}

示例代码要点：

• wait所在的goroutine要判定是否需要wait，所以wait要出现在条件中，因为goroutine调用的关系，不能保证wait在broadcast前面执行

• wait要使用for进行条件判定，因为在wait返回后，条件不一定成立。因为Broadcast()操作可能被提前调用（通常是在其他的goroutine中。

• Broadcast() 操作可选的是否加锁解锁

• Wait() 操作前，一定要加锁。因为Wait()操作，会先解锁，接收到信号后，再加锁。

sync.Cond 基本原理

sync.Cond结构：

type Cond struct {
    // 锁
    L Locker
    // 等待通知goroutine列表
    notify  notifyList

    // 限制不能被拷贝
    noCopy noCopy
    checker copyChecker
}

结构上可见，Cond记录了等待的goroutine列表，这样就可以做到，广播到全部的等待goroutine。这也是Cond应该被复制的原因，否则这些goroutine可能会被意外唤醒。

Wait() 操作：

func (c *Cond) Wait() {
   // 检查是否被复制
   c.checker.check()
   // 更新 notifyList 中需要等待的 waiter 的数量
   // 返回当前需要插入 notifyList 的编号
   t := runtime_notifyListAdd(&c.notify)
   // 解锁
   c.L.Unlock()
   // 挂起，直到被唤醒
   runtime_notifyListWait(&c.notify, t)
   // 唤醒之后，重新加锁。
   // 因为阻塞之前解锁了。
   c.L.Lock()
}

核心工作就是，记录当goroutine到Cond的notifyList。之后解锁，挂起，加锁。因此要在Wait()前加锁，后边要解锁。

Broadcast()操作：

func (c *Cond) Broadcast() {
   // 检查 sync.Cond 是否被复制了
   c.checker.check()
   // 唤醒 notifyList 中的所有 goroutine
   runtime_notifyListNotifyAll(&c.notify)
}

核心工作就是唤醒 notifyList 中全部的 goroutine。

小结

同步类型：

• 数据同步，保证数据操作的原子性

  • sync/atomic

  • sync.Map

  • sync.Mutex, sync.RWMutex

• 操作同步

  • sync.Mutex, sync.RWMutex

锁的类型：

• 互斥锁 sync.Mutex，完全独占

• 读写互斥锁 sync.RWMutex，可以共享读操作

锁的不锁资源，只是锁定申请锁本身的操作。

sync包总结

• 锁：sync.Mutex, sync.RWMutex

• 数据：sync.Map, sync/atomic

• sync.Pool

• sync.Once

• sync.Cond

使用Channel完成数据和信号的同步！