提高 Golang 并发编程能力的必备利器：深入学习 sync.Cond 类型-六虎

Go 语言的 sync 包供给了一系列同步原语，其间 sync.Cond 就是其间之一。sync.Cond 的作用是在多个 goroutine 之间进行条件变量的同步。本文将深入探讨 sync.Cond 的完结原理和运用办法，帮助咱们更好地了解和应用 sync.Cond。

1. sync.Cond 的根本概念

1.1 条件变量

条件变量是一种同步机制，用于在多个 goroutine 之间进行同步。条件变量一般是和互斥锁一同运用的，用于等候某个条件的呈现。

在 Go 语言中，条件变量由 sync.Cond 类型完结。它供给了两个首要的办法：Wait 和 Signal/Broadcast。Wait 办法用于等候条件变量的呈现，Signal/Broadcast 办法用于通知等候中的 goroutine。

1.2 互斥锁

互斥锁是一种用于操控对共享资源拜访的同步机制。它能够保证同一时间只要一个 goroutine 能够拜访共享资源。

在 Go 语言中，互斥锁由 sync.Mutex 类型完结。它供给了两个首要的办法：Lock 和 Unlock。Lock 办法用于加锁，保证同一时间只要一个 goroutine 能够拜访共享资源；Unlock 办法用于解锁，允许其他 goroutine 拜访共享资源。

1.3 条件变量的完结原理

条件变量的完结原理基于互斥锁和 goroutine 行列。

假设有一个条件变量 cond，初始时它没有被触发。当一个 goroutine 调用 cond.Wait() 办法时，它会加锁并将自己参加到 cond 的 goroutine 行列中。接着，它会解锁并进入睡眠状况，等候被唤醒。

当另一个 goroutine 调用 cond.Signal() 或许 cond.Broadcast() 办法时，它会从头加锁，并从 cond 的 goroutine 行列中挑选一个 goroutine 唤醒。被唤醒的 goroutine 会从头加锁，然后持续履行。

需求留意的是，被唤醒的 goroutine 并不会立即履行，它会等候从头取得锁之后才会持续履行。

2. sync.Cond 的根本用法

2.1 创立 sync.Cond 目标

sync.Cond 目标需求依靠一个 sync.Mutex 或 sync.RWMutex 目标来进行同步和互斥操作。咱们能够运用 sync.NewCond 办法来创立一个新的 sync.Cond 目标，该办法接受一个 Mutex 或 RWMutex 目标作为参数，回来一个对应的条件变量目标。

package main

import (
  "fmt"
  "sync"
)

func main() {
  var mu sync.Mutex
  cond := sync.NewCond(&mu)

  // ...
}

2.2 等候条件变量

sync.Cond 供给了 Wait 办法来等候条件变量的信号。Wait 办法需求在持有 Mutex 或 RWMutex 的情况下进行调用，否则会抛出 panic 反常。

func (c *Cond) Wait()

Wait 办法将当时 goroutine 暂停，等候条件变量的信号。在等候过程中，Mutex 或 RWMutex 将被开释，其他 goroutine 能够获取锁并修正共享变量，可是当时 goroutine 仍然保持在等候行列中，直到收到唤醒信号。当 Wait 办法回来时，Mutex 或 RWMutex 会自动从头被确定。

下面是一个简略的示例程序，运用 sync.Cond 完结了一个简略的条件等候机制：

package main

import (
  "fmt"
  "sync"
  "time"
)

func main() {
  var mu sync.Mutex
  cond := sync.NewCond(&mu)
  var ready bool

  // 模仿一个耗时的初始化操作
  go func() {
    time.Sleep(2 * time.Second)
    mu.Lock()
    ready = true
    cond.Signal() // 唤醒等候的 goroutine
    mu.Unlock()
   }()

  mu.Lock()
  for !ready {
    cond.Wait() // 等候初始化完结信号
   }
  fmt.Println("Initialization completed")
  mu.Unlock()
}

上面的示例程序中，咱们经过 sync.Cond 完结了一种等候初始化完结的机制。在初始化完结前，主 goroutine 会等候条件变量的信号，当子 goroutine 完结初始化后，会经过 Signal 办法发送唤醒信号，使得主 goroutine 持续履行。

2.3 唤醒等候的 goroutine

sync.Cond 供给了两种办法来唤醒等候的 goroutine：Signal 和 Broadcast。

2.3.1 Signal 办法

Signal 办法用于唤醒等候行列中的一个 goroutine，使其持续履行。在调用 Signal 办法之前，必须先取得 Mutex 或 RWMutex 的锁。

func (c *Cond) Signal()

Signal 办法会挑选等候行列中的一个 goroutine 并唤醒它，如果没有等候的 goroutine，那么 Signal 办法不会发生任何作用。

下面是一个示例程序，演示了怎么运用 Signal 办法唤醒等候的 goroutine：

package main

import (
  "fmt"
  "sync"
  "time"
)

func main() {
  var mu sync.Mutex
  cond := sync.NewCond(&mu)
  var ready bool

  // 模仿一个耗时的初始化操作
  go func() {
    time.Sleep(2 * time.Second)
    mu.Lock()
    ready = true
    cond.Signal() // 唤醒等候的 goroutine
    mu.Unlock()
   }()

  mu.Lock()
  for !ready {
    cond.Wait() // 等候初始化完结信号
   }
  fmt.Println("Initialization completed")
  mu.Unlock()
}

在上面的示例程序中，咱们经过调用 cond.Signal() 办法来唤醒等候的 goroutine。

2.3.2 Broadcast 办法

Broadcast 办法用于唤醒等候行列中的一切 goroutine，使它们持续履行。在调用 Broadcast 办法之前，必须先取得 Mutex 或 RWMutex 的锁。

func (c *Cond) Broadcast()

Broadcast 办法会唤醒等候行列中的一切 goroutine，如果没有等候的 goroutine，那么 Broadcast 办法不会发生任何作用。

下面是一个示例程序，演示了怎么运用 Broadcast 办法唤醒等候的 goroutine：

package main

import (
  "fmt"
  "sync"
  "time"
)

func main() {
  var mu sync.Mutex
  cond := sync.NewCond(&mu)
  var ready bool

  // 模仿一个耗时的初始化操作
  go func() {
    time.Sleep(2 * time.Second)
    mu.Lock()
    ready = true
    cond.Broadcast() // 唤醒等候的一切 goroutine
    mu.Unlock()
   }()

  mu.Lock()
  for !ready {
    cond.Wait() // 等候初始化完结信号
   }
  fmt.Println("Initialization completed")
  mu.Unlock()
}

在上面的示例程序中，咱们经过调用 cond.Broadcast() 办法来唤醒等候的 goroutine。

3. sync.Cond 的内部完结原理

sync.Cond 的内部完结依靠于一个等候行列，它保护了等候条件变量的 goroutine 的列表，其间每个 goroutine 都有一个堵塞的状况。当条件变量被发出信号时，等候行列中的一个 goroutine 将被唤醒，并从 Wait 办法中回来，一起将从头取得 Mutex 的锁。

下面是 sync.Cond 内部的等候行列结构体界说：

type wait struct {
  // 等候行列中的 goroutine
  // goroutine 在 cond.Wait() 中被参加行列，在 cond.Signal() 或 cond.Broadcast() 中被唤醒
  // 因为行列是单向链表，因此需求保存 next 指针指向下一个元素
  // 当 goroutine 被唤醒时，会将 wait.done 设置为 true，并唤醒 wait.cond.L 上堵塞的 goroutine
  // goroutine 从 Wait() 办法中回来时，会将 wait.done 设置为 true
  // wait.done 能够保证 goroutine 不会重复地从 cond.Wait() 办法中回来
  // wait.done 能够保证 goroutine 在从 cond.Wait() 办法中回来时，现已持有了 Mutex 的锁
  // wait.done 能够保证 goroutine 在被唤醒之前不会在 cond.Wait() 办法中被从头参加到行列中
  done bool
  // 下一个等候行列元素的指针
  next *wait
  // 条件变量
  cond *Cond
}

sync.Cond 运用 wait 结构体保护了一个等候行列，其间每个元素都代表了一个等候 goroutine。

wait 结构体中的 done 字段用于保证 goroutine 不会重复地从 Wait 办法中回来，next 字段用于链接下一个等候元素。

等候行列的头部和尾部别离运用 wait 结构体的指针 first 和 last 保护。

type Cond struct {
  // Mutex 保护 condition 变量和等候行列
  L Locker

  // 等候行列的头部和尾部
  first *wait
  last *wait
}

sync.Cond 的 Wait 办法完结如下：

func (c *Cond) Wait() {
  // 将当时 goroutine 参加到等候行列中
  t := new(wait)
  t.cond = c
  c.add(t)
  defer c.remove(t)

  // 开释锁并进入堵塞状况
  c.L.Unlock()
  for !t.done {
    runtime.Gosched()
   }
  c.L.Lock()
}

在 Wait 办法中，首要创立一个 wait 结构体 t，并将当时 goroutine 参加到等候行列中，然后开释 Mutex 的锁，并进入堵塞状况。

在等候行列中，goroutine 的状况为堵塞，直到被唤醒并从 Wait 办法中回来。

当等候的条件变量满意时，唤醒等候行列中的 goroutine 的操作由 Signal 和 Broadcast 办法来完结。

Signal 办法会唤醒等候行列中的一个 goroutine，而 Broadcast 办法会唤醒一切等候行列中的 goroutine。

func (c *Cond) Signal() {
  if c.first != nil {
    c.first.wake(true)
   }
}

func (c *Cond) Broadcast() {
  for c.first != nil {
    c.first.wake(true)
    }
}

在 Signal 和 Broadcast 办法中，首要判别等候行列是否为空，如果不为空，则唤醒等候行列中的一个或一切 goroutine，并将它们从堵塞状况中免除。下面是 wait 结构体的 wake 办法完结：

func (w *wait) wake(done bool) {
  // 标记 done 字段并免除堵塞状况
  w.done = done
  runtime.NotifyListNotify(&w.cond.L.(*Mutex).notify)
}

在 wake 办法中，首要将 wait.done 设置为 true，然后经过调用 runtime.NotifyListNotify 办法，将等候行列中的 goroutine 从堵塞状况中免除。

这儿需求留意的是，在 sync.Cond 的完结中，运用了 Mutex 的 notify 字段来完结 goroutine 的唤醒和堵塞。

当一个 goroutine 调用 Wait 办法时，它会开释 Mutex 的锁，并进入堵塞状况，一起将自己参加到 Mutex 的 notify 行列中。

当一个 goroutine 调用 Signal 或 Broadcast 办法时，它会从 Mutex 的 notify 行列中取出一个或多个 goroutine，并唤醒它们。

这种完结办法与操作系统的线程调度机制相似，能够保证唤醒的 goroutine 在调用 Wait 办法时现已持有了 Mutex 的锁，然后防止了死锁和竞态条件等问题。

这儿再补充一下 Mutex 的 notify 字段的界说：

type Mutex struct {
  state int32
  sema uint32
  waitm uint32
  notify notifyList
}

notify 字段是一个 notifyList 类型的目标，它界说如下：

type notifyList struct {
  wait  uint32 // 等候的 goroutine 的数量
  notify uint32 // 唤醒的 goroutine 的数量
  head  *wait // 等候行列的头部元素
  tail  *wait // 等候行列的尾部元素
}

notifyList 类型的目标保护了一个等候行列和唤醒行列，其间等候行列用于寄存堵塞的 goroutine，唤醒行列用于寄存将要被唤醒的 goroutine。

notifyList 类型的目标还保护了等候行列和唤醒行列中 goroutine 的数量。

当一个 goroutine 调用 Wait 办法时，它会将自己参加到等候行列中，并且将 Mutex 的 waitm 字段加一。

当一个 goroutine 调用 Signal 或 Broadcast 办法时，它会从等候行列中取出一个或多个 goroutine，并将它们参加到唤醒行列中。

当一个 goroutine 调用 Unlock 办法时，它会判别唤醒行列中是否有 goroutine 需求唤醒，并将 Mutex 的 sema 字段加一，然后使得下一个 goroutine 取得锁。

4. sync.Cond 的运用办法

sync.Cond 的运用办法一般包括以下过程：

界说互斥锁和条件变量。

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

在生产者和顾客之间运用互斥锁和条件变量进行同步。

package main

import (
  "fmt"
  "math/rand"
  "sync"
  "time"
)

type Queue struct {
  items []int
  size int
  lock sync.Mutex
  cond *sync.Cond
}

func NewQueue(size int) *Queue {
  q := &Queue{
    items: make([]int, 0, size),
    size: size,
   }
  q.cond = sync.NewCond(&q.lock)
  return q
}

func (q *Queue) Put(item int) {
  q.lock.Lock()
  defer q.lock.Unlock()

  for len(q.items) == q.size {
    q.cond.Wait()
   }

  q.items = append(q.items, item)
  fmt.Printf("put item %d, queue len %d\n", item, len(q.items))

  q.cond.Signal()
}

func (q *Queue) Get() int {
  q.lock.Lock()
  defer q.lock.Unlock()

  for len(q.items) == 0 {
    q.cond.Wait()
   }

  item := q.items[0]
  q.items = q.items[1:]
  fmt.Printf("get item %d, queue len %d\n", item, len(q.items))

  q.cond.Signal()
  return item
}

func Producer(q *Queue, id int) {
  for {
    item := rand.Intn(100)
    q.Put(item)
    time.Sleep(time.Duration(rand.Intn(1000)) * time.Millisecond)
   }
}

func Consumer(q *Queue, id int) {
  for {
    item := q.Get()
    time.Sleep(time.Duration(rand.Intn(1000)) * time.Millisecond)
   }
}

func main() {
  q := NewQueue(5)
  for i := 0; i < 3; i++ {
    go Producer(q, i)
   }
  for i := 0; i < 5; i++ {
    go Consumer(q, i)
   }
  time.Sleep(10 * time.Second)
}

在这个比如中，咱们创立了一个 Queue 类型，它包括一个整数数组和一个长度。在 Put 和 Get 办法中，咱们运用互斥锁和条件变量进行同步。

在 Producer 和 Consumer 函数中，咱们模仿生产者和顾客的行为。生产者会不断地生成随机数，并调用 Put 办法将其放入行列中；顾客会不断地调用 Get 办法从行列中取出数据。

在主函数中，咱们创立了多个生产者和顾客 goroutine，它们并发地操作行列。在程序运行过程中，咱们能够看到行列的长度会不断地改变，生产者和顾客会替换履行。

5. 总结

sync.Cond 是 Go 语言中非常重要的同步原语之一。它能够帮助咱们完结更高等级的同步机制，例如生产者和顾客模型、读写锁等。一起，它也是一个非常复杂的数据结构，需求深入了解其内部完结才干正确地运用它。

在运用 sync.Cond 时，咱们需求留意以下几点：

在运用 sync.Cond 前，必定要先创立一个互斥锁。
在调用 Wait 办法前，必定要先获取互斥锁，否则会导致死锁。
在调用 Wait 办法后，当时 goroutine 会被堵塞，直到被唤醒。
在调用 Signal 或 Broadcast 办法后，等候行列中的一个或多个 goroutine 会被唤醒，但不会立即获取互斥锁。因此，在运用 Signal 或 Broadcast 办法时，必定要保证唤醒的 goroutine 不会互相竞赛同一个资源。
在调用 Signal 或 Broadcast 办法后，必定要开释互斥锁，否则被唤醒的 goroutine 无法获取到互斥锁，仍然会被堵塞。
在运用 sync.Cond 时，必定要留意竞赛条件和数据同步的问题，保证程序的正确性和稳定性。

在本文中，咱们介绍了 sync.Cond 的根本用法和内部完结原理，并经过一个实践的生产者和顾客模型的比如，展现了怎么运用 sync.Cond 完结高等级的同步机制。

运用 sync.Cond 能够帮助咱们完结更高效、更灵活、更安全的并发程序。但一起，也需求咱们细心考虑和了解其内部完结，防止呈现竞赛条件和数据同步的问题，保证程序的正确性和稳定性。

总之，Golang 的 sync.Cond 类型是 Golang 并发编程中非常重要的一个组件，熟练掌握它的运用办法和完结原理，能够有效提高 Golang 并发编程的能力和水平。

提高 Golang 并发编程能力的必备利器：深入学习 sync.Cond 类型

1. sync.Cond 的根本概念

1.1 条件变量

1.2 互斥锁

1.3 条件变量的完结原理

2. sync.Cond 的根本用法

2.1 创立 sync.Cond 目标

2.2 等候条件变量

2.3 唤醒等候的 goroutine

2.3.1 Signal 办法

2.3.2 Broadcast 办法

3. sync.Cond 的内部完结原理

4. sync.Cond 的运用办法

5. 总结

相关文章

Windows11 Rust安装

Java Stream API 操作完全攻略：让你的代码更加出色 (一)

【入门】干货|UI设计师的工作内容与工作流程

HarmonyOS 开发案例分享：万能卡片也能用来玩游戏

作者信息