1.sync.Mutex和sync.RWMutex

要知道，mutex（互斥）对于我们 gopher 来说就像一个老伙计。在处理 goroutine 时，确保它们不会同时访问资源是非常重要的，而 mutex 可以帮助我们做到这一点。

sync.Mutex

看看这个简单的例子，我没有使用互斥锁来保护我们的变量 a：

var a = 0

func Add() {
  a++
}

func main() {
  for i := 0; i < 500; i++ {
    go Add()
  }

  time.Sleep(5 * time.Second)
  fmt.Println(a)
}

此代码的结果是不可预测的。如果幸运的话，您可能会得到 500，但通常结果会小于 500。现在，让我们使用互斥体增强我们的 Add 函数：

var mtx = sync.Mutex{}

func Add() {
  mtx.Lock()
  defer mtx.Unlock()
  a++
}

现在，代码提供了预期的结果。但是使用 sync.RWMutex 呢？

为什么使用 sync.RWMutex？

想象一下，您正在检查 a 变量，但其他 goroutines 也在调整它。您可能会得到过时的信息。那么，解决这个问题的方法是什么？

让我们退后一步，使用我们的旧方法，将 sync.Mutex 添加到我们的 Get() 函数中：

func Add() {
  mtx.Lock()
  defer mtx.Unlock()

  a++
}

func Get() int {
  mtx.Lock()
  defer mtx.Unlock()

  return a
}

但这里的问题是，如果您的服务或程序调用 Get() 数百万次而只调用 Add() 几次，那么我们实际上是在浪费资源，因为我们大部分时间甚至都没有修改它而将所有内容都锁定了。

这就是 sync.RWMutex 突然出现来拯救我们的一天，这个聪明的小工具旨在帮助我们处理同时读取和写入的情况。

var mtx = sync.RWMutex{}

func Add() {
  mtx.Lock()
  defer mtx.Unlock()
  
  a++
}

func Look() {
  mtx.RLock()
  defer mtx.RUnlock()
  
  fmt.Println(a)
}

那么，RWMutex 有什么了不起的呢？好吧，它允许数百万次并发读取，同时确保一次只能进行一次写入。让我澄清一下它是如何工作的：

• 写入时，读取被锁定。
• 读取时，写入被锁定。
• 多次读取不会相互锁定。

sync.Locker

哦对了，Mutex和RWMutex都实现了sync.Locker接口{}，签名是这样的：

// A Locker represents an object that can be locked and unlocked.
type Locker interface {
  Lock()
  Unlock()
}

如果你想创建一个接受 Locker 的函数，你可以将这个函数与你的自定义 locker 或同步互斥锁一起使用：

func Add(mtx sync.Locker) {
  mtx.Lock()
  defer mtx.Unlock()
  
  a++
}

2. sync.WaitGroup

您可能已经注意到我使用了 time.Sleep(5 * time.Second) 来等待所有 goroutine 完成，但老实说，这是一个非常丑陋的解决方案。

这就是 sync.WaitGroup 出现的地方：

func main() {
  wg := sync.WaitGroup{}
  for i := 0; i < 500; i++ {
    wg.Add(1)
    go func() {
      defer wg.Done()
      Add()
    }()
  }
  
  wg.Wait()
  fmt.Println(a)
}

sync.WaitGroup 有 3 个主要方法：Add、Done 和 Wait。

首先是 Add(delta int)：此方法将 WaitGroup 计数器增加 delta 的值。你通常会在生成 goroutine 之前调用它，表示有一个额外的任务需要完成。

如果我们将 WaitGroup 放在 go func() {} 中，您认为会发生什么？

go func() {
  wg.Add(1)
  defer wg.Done()
  Add()
}()

我的编译器喊道，“应该在启动 goroutine 之前调用 wg.Add(1) 以避免竞争”，我的运行时出现恐慌，“panic: sync: WaitGroup is reused before previous Wait has returned”。

其他两种方法非常简单：

• 当一个 goroutine 结束它的任务时， Done 被调用。
• Wait 会阻塞调用者，直到 WaitGroup 计数器归零，这意味着所有派生的 goroutine 都已完成它们的任务。

3. sync.Once

假设您在一个包中有一个 CreateInstance() 函数，但您需要确保它在使用前已初始化。所以你在不同的地方多次调用它，你的实现看起来像这样：

var i = 0
var _isInitialized = false

func CreateInstance() {
  if _isInitialized {
    return
  }
  
  i = GetISomewhere()
  _isInitialized = true
}

但是如果有多个 goroutine 调用这个方法呢？ i = GetISomeWhere 行会运行多次，即使您为了稳定性只希望它执行一次。

您可以使用我们之前讨论过的互斥锁，但同步包提供了一种更方便的方法：sync.Once

var i = 0
var once = &sync.Once{}

func CreateInstance() {
  once.Do(func() {
    i = GetISomewhere()
  })
}

使用 sync.Once，你可以确保一个函数只执行一次，不管它被调用了多少次或者有多少 goroutines 同时调用它。

4. sync.Pool

想象一下，你有一个池，里面有一堆你想反复使用的对象。这可以减轻垃圾收集器的一些压力，尤其是在创建和销毁这些资源的成本很高的情况下。

所以，无论何时你需要一个对象，你都可以从池中取出它。当您使用完它时，您可以将它放回池中以备日后重复使用。

var pool = sync.Pool{
  New: func() interface{} {
    return 0
  },
}

func main() {
  pool.Put(1)
  pool.Put(2)
  pool.Put(3)
  
  a := pool.Get().(int)
  b := pool.Get().(int)
  c := pool.Get().(int)
  
  fmt.Println(a, b, c) // Output: 1, 3, 2 (order may vary)
}

请记住，将对象放入池中的顺序不一定是它们出来的顺序，即使多次运行上述代码时顺序也是随机。

让我分享一些使用 sync.Pool 的技巧：

• 它非常适合长期存在并且有多个实例需要管理的对象，例如数据库连接（1000 个连接？）、worker goroutine，甚至缓冲区。
• 在将对象返回池之前始终重置对象的状态。这样，您可以避免任何无意的数据泄漏或奇怪的行为。
• 不要指望池中已经存在的对象，因为它们可能会意外释放。

5. sync.Map

当您同时使用 map 时，有点像使用 RWMutex。您可以同时进行多次读取，但不能进行多次读写或写入。如果存在冲突，您的服务将崩溃而不是覆盖数据或导致意外行为。

这就是 sync.Map 派上用场的地方，因为它可以帮助我们避免这个问题。让我们仔细看看 sync.Map 给我们提供什么：

• CompareAndDelete (go 1.20)：如果值匹配则删除键的条目；如果不存在值或旧值为 nil，则返回 false。
• CompareAndSwap（go 1.20）：如果新旧值匹配，则交换一个键，只要确保旧值是可比较的。
• Swap (go 1.20)：交换键的值并返回旧值（如果存在）。
• LoadOrStore：获取当前键值或保存并返回提供的值（如果不存在）
• Range (f func(key, value any)：遍历映射，将函数 f 应用于每个键值对。如果 f 说返回 false，它会停止。
• Store
• Delete
• Load
• LoadAndDelete

Q: 我们为什么不使用带有 Mutex 的常规 map 呢？

我通常选择带有 RWMutex 的 map，但在某些情况下认识到 sync.Map 的强大功能很重要。那么，它真正发光的地方在哪里呢？

如果您有许多 goroutines 访问 map 中的单独键，则具有单个互斥锁的常规 map 可能会导致争用，因为它仅针对单个写操作锁定整个 map。

另一方面，sync.Map 使用更完善的锁定机制，有助于最大限度地减少此类场景中的争用。

6. sync.Cond

将 sync.Cond 视为支持多个 goroutine 等待和相互交互的条件变量。为了更好地理解，让我们看看如何使用它。

首先，我们需要创建带有 Locker 的 sync.Cond：

var mtx sync.Mutex
var cond = sync.NewCond(&mtx)

goroutine 调用 cond.Wait 并等待来自其他地方的信号以继续执行：

func dummyGoroutine(id int) {
  cond.L.Lock()
  defer cond.L.Unlock()
  fmt.Printf("Goroutine %d is waiting...\n", id)
  cond.Wait()
  fmt.Printf("Goroutine %d received the signal.\n", id)
}

然后，另一个 goroutine（就像主 goroutine）调用 cond.Signal()，让我们等待的 goroutine 继续：

func main() {
  go dummyGoroutine(1)
  
  time.Sleep(1 * time.Second)

  fmt.Println("Sending signal...")
  cond.Signal()

  time.Sleep(1 * time.Second)
}

结果如下所示：

Goroutine 1 is waiting...
Sending signal...
Goroutine 1 received the signal.

如果有多个 goroutines 在等待我们的信号怎么办？这就是我们可以使用广播的时候：

func main() {
  go dummyGoroutine(1)
  go dummyGoroutine(2)
  
  time.Sleep(1 * time.Second)
  cond.Broadcast() // broadcast to all goroutines
  time.Sleep(1 * time.Second)
}

结果如下所示：

Goroutine 1 is waiting...
Goroutine 2 is waiting...
Goroutine 2 received the signal.
Goroutine 1 received the signal.

1111