Go语言Sync包

Go语言Sync包

1、sync.Mutex和sync.RWMutex

在处理 goroutine 时，确保它们不会同时访问资源是非常重要的，而 mutex 可以帮助我们做到这一点。

1.1 sync.Mutex

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

package main

import (
	"fmt"
	"time"
)

var a = 0

func Add() {
	a++
}

func main() {
	for i := 0; i < 500; i++ {
		go Add()
	}
	time.Sleep(2 * time.Second)
	// 595
	fmt.Println(a)
}

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

增强我们的 Add 函数：

package main

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

var a = 0

var mtx = sync.Mutex{}

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

func main() {
	for i := 0; i < 500; i++ {
		go Add()
	}
	time.Sleep(2 * time.Second)
	// 500
	fmt.Println(a)
}

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

1.2 sync.RWMutex

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

的方法是什么?

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

package main

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

var a = 0

var mtx = sync.Mutex{}

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

func Get() int {
	mtx.Lock()
	defer mtx.Unlock()
	return a
}

func main() {
	for i := 0; i < 500; i++ {
		go Add()
	}
	for i := 0; i < 5; i++ {
		fmt.Println(Get())
	}
	time.Sleep(2 * time.Second)
	// 500
	fmt.Println(a)
}

# 输出
491
500
500
500
500
500

但这里的问题是，如果您的服务或程序调用 Get() 数百万次而只调用 Add() 几次，那么我们实际上是在浪费资源，

因为我们大部分时间甚至都没有修改它而将所有内容都锁定了。

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

况。

package main

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

var a = 0

var mtx = sync.RWMutex{}

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

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

func main() {
	for i := 0; i < 500; i++ {
		go Add()
	}
	for i := 0; i < 5; i++ {
		Look()
	}
	time.Sleep(2 * time.Second)
	// 500
	fmt.Println(a)
}

# 输出
480
481
482
483
484
500

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

清一下它是如何工作的：

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

2、sync.Locker

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

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

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

package main

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

var a = 0

var mtx = sync.Mutex{}

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

func main() {
	for i := 0; i < 500; i++ {
		go Add(&mtx)
	}
	time.Sleep(2 * time.Second)
	// 500
	fmt.Println(a)
}

3、sync.WaitGroup

您可能已经注意到我使用了 time.Sleep(2 * time.Second) 来等待所有 goroutine 完成，但老实说，这是一个非常

丑陋的解决方案。

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

package main

import (
	"fmt"
	"sync"
)

var a = 0

var mtx = sync.Mutex{}

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

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 之前调用它，表

示有一个额外的任务需要完成。

其他两种方法非常简单：

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

4、sync.Once

假设您在一个包中有一个 CreateInstance() 函数，但您需要确保它在使用前已初始化。所以你在不同的地方多次

调用它，你的实现看起来像这样：

var i = 0
var _isInitialized = false

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

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

行一次。

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

package main

import (
	"math/rand"
	"sync"
)

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

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

func GetISomewhere() int {
	return rand.Int()
}

func main() {
	CreateInstance()
}

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

5、sync.Pool

5.1 简单使用

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

毁这些资源的成本很高的情况下。

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

用。

package main

import (
	"fmt"
	"sync"
)

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)
    // 1 3 2
	fmt.Println(a, b, c)
}

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

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

• 它非常适合长期存在并且有多个实例需要管理的对象，例如数据库连接(1000 个连接)、worker goroutine，

  甚至缓冲区。

• 在将对象返回池之前始终重置对象的状态。这样，您可以避免任何无意的数据泄漏或奇怪的行为。

• 不要指望池中已经存在的对象，因为它们可能会意外释放。

5.2 介绍

在 Golang 中，sync.Pool 是一个非常有用的工具。它是用于存储和重用临时对象的池。在高并发的情况下，

sync.Pool 可以显著提高程序的性能，减少内存分配和垃圾回收的压力。本文将详细介绍 sync.Pool 的使用方法和

注意事项，希望能对广大 Golang 程序员有所帮助。

5.3 基本用法

sync.Pool 的基本用法非常简单。我们只需要创建一个 sync.Pool 对象，然后在需要使用临时对象的时候，从池中

取出对象即可。如果池中没有可用的对象，那么 Pool.Get() 方法会返回 nil。当我们用完对象之后，需要将其放回

池中，以便下次使用。

package main

import (
	"fmt"
	"sync"
)

func main() {
	pool := &sync.Pool{
		New: func() interface{} {
			return "Hello, World!"
		},
	}
	// 从池中取出对象
	obj := pool.Get()
	// 输出：Hello, World!
	fmt.Println(obj)
	// 将对象放回池中
	pool.Put(obj)
	// 再次从池中取出对象
	obj = pool.Get()
	// 输出：Hello, World!
	fmt.Println(obj)
}

# 输出
Hello, World!
Hello, World!

在上面的示例中，我们创建了一个池，池中存储的是字符串 “Hello, World!”。我们首先从池中取出对象，然后将

其放回池中，最后再次取出对象。由于我们只创建了一个对象，所以两次输出的结果都是相同的。

5.4 高级用法

除了上面的基本用法之外，sync.Pool 还有一些高级用法，可以让我们更好地掌控池中对象的生命周期。下面我们

来逐一介绍这些用法。

5.4.1 生命周期

sync.Pool 中存储的对象并不会一直存在，它们的生命周期是由垃圾回收器控制的。如果一个对象在一定时间内没

有被使用，那么它就会被垃圾回收器回收。这个时间是不确定的，它取决于垃圾回收器的具体实现。

因此，我们不能依赖 sync.Pool 中的对象一直存在，必须在每次使用之前都检查对象是否为空。如果对象为空，那

么我们需要重新创建一个对象并放入池中。

5.4.2 GC 问题

由于 sync.Pool 中的对象是由垃圾回收器控制的，因此在使用 sync.Pool 时，需要注意避免对象被过早地回收。如

果我们在使用对象时没有及时将其放回池中，那么垃圾回收器可能会将对象回收，从而导致程序出现问题。

为了避免这种情况的发生，我们可以使用 sync.Pool 的 Finalizer 方法。Finalizer 方法可以在对象被回收之前执行

一些清理操作，从而保证对象在被回收之前能够被正确地处理。

下面是一个示例：

package main

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

type Foo struct {
	Name string
}

func (f *Foo) Close() {
	fmt.Printf("Closing Foo %s\n", f.Name)
}

func main() {
	pool := &sync.Pool{
		New: func() interface{} {
			return &Foo{Name: "Bar"}
		},
	}

	// 从池中取出对象
	obj := pool.Get().(*Foo)
	fmt.Println(obj.Name) // 输出：Bar

	// 将对象放回池中
	pool.Put(obj)

	// 等待 1 秒钟
	time.Sleep(time.Second)

	// 再次从池中取出对象
	obj = pool.Get().(*Foo)
	fmt.Println(obj.Name) // 输出：Bar

	// 使用 Finalizer 方法
	runtime.SetFinalizer(obj, func(f *Foo) {
		f.Close()
	})

	// 等待 1 秒钟
	time.Sleep(time.Second)
}

# 输出
Bar
Bar

在上面的示例中，我们创建了一个 Foo 对象，并将其放入 sync.Pool 中。我们在使用对象之前，等待了 1 秒钟，

从而模拟对象被长时间占用的情况。然后我们再次从池中取出对象，并使用 Finalizer 方法为其设置一个回收方

法。该回收方法会在对象被回收之前执行，从而保证对象能够被正确地处理。

5.4.3 并发安全性

sync.Pool 对象本身是并发安全的。多个 goroutine 可以同时访问同一个 sync.Pool 对象，并且不需要额外的锁来

保证并发安全性。这是因为 sync.Pool 内部使用了 sync.Mutex 来保证并发安全性。

但是，需要注意的是，由于 sync.Pool 中存储的对象是共享的，因此我们需要在使用对象时进行一些额外的同步操

作，以避免出现竞态条件。例如，如果我们从池中取出一个对象，然后对其进行修改，那么其他 goroutine 可能

会同时访问到同一个对象，从而导致数据竞争。

下面是一个示例：

package main

import (
	"fmt"
	"sync"
)

type Counter struct {
	mu    sync.Mutex
	count int
}

func (c *Counter) Add(n int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.count += n
}

func (c *Counter) Value() int {
	c.mu.Lock()
	defer c.mu.Unlock()
	return c.count
}

func main() {
	pool := &sync.Pool{
		New: func() interface{} {
			return &Counter{}
		},
	}

	// 从池中取出对象
	counter := pool.Get().(*Counter)

	// 对对象进行修改
	counter.Add(1)

	// 将对象放回池中
	pool.Put(counter)

	// 再次从池中取出对象
	counter = pool.Get().(*Counter)

	// 对对象进行修改
	counter.Add(1)

	// 输出对象的值
	fmt.Println(counter.Value()) // 输出：2
}

# 输出
2

在上面的示例中，我们创建了一个 Counter 对象，并将其放入 sync.Pool 中。我们首先从池中取出对象，并对其

进行修改。然后将对象放回池中，再次取出对象，并对其进行修改。最后输出对象的值。由于我们对同一个对象进

行了两次修改，因此输出的结果是 2。

6、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

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

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

地方在哪里呢？

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

单个写操作锁定整个 map。

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

package main

import (
	"fmt"
	"sync"
)

func main()  {
	var m sync.Map
	// 1. 写入
	m.Store("aa", 18)
	m.Store("bb", 20)

	// 2. 读取
	age, _ := m.Load("aa")
	fmt.Println(age.(int))

	// 3. 遍历
	m.Range(func(key, value interface{}) bool {
		name := key.(string)
		age := value.(int)
		fmt.Println(name, age)
		return true
	})

	// 4. 删除
	m.Delete("aa")
	age, ok := m.Load("aa")
	fmt.Println(age, ok)

	// 5. 读取或写入
	// 这个key已经存在,因此写入不成功,并且读出原值
	m.LoadOrStore("bb", 100)
	age, _ = m.Load("bb")
	fmt.Println(age)
}

# 程序输出
18
aa 18
bb 20
<nil> false
20

7、sync.Cond

在并发编程中，条件变量是一种常用的线程间协作机制，它可以让一个或多个线程等待某个条件的满足，从而实现

线程间的同步和通信。在 Go 语言中，sync 包提供了 Cond 类型来支持条件变量的使用。

sync.Cond 是基于互斥锁/读写锁实现的条件变量，用来协调想要访问共享资源的那些 Goroutine。当共享资源状

态发生变化时，sync.Cond 可以用来通知等待条件发生而阻塞的 Goroutine。

sync.Cond 基于互斥锁/读写锁，那它和互斥锁有什么区别呢？

互斥锁 sync.Mutex 通常用来保护共享的临界资源，条件变量 sync.Cond 用来协调想要访问共享资源的

Goroutine。当共享资源的状态发生变化时，sync.Cond 可以用来通知被阻塞的 Goroutine。

下面将深入探讨 sync.Cond 的使用方法和注意事项，帮助你更好地理解 Go 语言中的并发编程。

7.1 简单案例

将 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)
}

总代码：

package main

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

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

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)
}

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 在等待我们的信号怎么办? 这就是我们可以使用广播的时候：

package main

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

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

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)
}

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

结果如下所示：

# 输出
Goroutine 1 is waiting...
Goroutine 2 is waiting...
Goroutine 2 received the signal.
Goroutine 1 received the signal.

7.2 实现原理

条件变量的实现原理基于互斥锁和 goroutine 队列。

假设有一个条件变量 cond，初始时它没有被触发。当一个 goroutine 调用 cond.Wait() 方法时，它会加锁并将自

己加入到 cond 的 goroutine 队列中。接着，它会解锁并进入睡眠状态，等待被唤醒。

当另一个 goroutine 调用 cond.Signal() 或者 cond.Broadcast() 方法时，它会重新加锁，并从 cond 的 goroutine

队列中选择一个 goroutine 唤醒。被唤醒的 goroutine 会重新加锁，然后继续执行。

需要注意的是，被唤醒的 goroutine 并不会立即执行，它会等待重新获得锁之后才会继续执行。

7.3 Cond 类型

Cond 类型是 Go 语言中的条件变量类型，它的定义如下：

type Cond struct {
    // contains filtered or unexported fields
}

Cond 类型包含了一些私有字段，我们无法直接访问它们。但是，sync 包提供了一些方法来操作 Cond 类型的实

例。

7.4 NewCond创建实例

sync.Cond 对象需要依赖一个 sync.Mutex 或 sync.RWMutex 对象来进行同步和互斥操作。我们可以使用

sync.NewCond 方法来创建一个新的 sync.Cond 对象，该方法接受一个 Mutex 或 RWMutex 对象作为参数，返回

一个对应的条件变量对象。

func NewCond(l Locker) *Cond

7.5 Wait 方法

sync.Cond 提供了 Wait 方法来等待条件变量的信号。Wait 方法需要在持有 Mutex 或 RWMutex 的情况下进行调

用，否则会抛出 panic 异常。

Wait 方法是 Cond 类型的核心方法之一，它用于等待条件变量的满足。Wait 方法的定义如下：

func (c *Cond) Wait()

Wait 方法将当前 goroutine 暂停，等待条件变量的信号。在等待过程中，Mutex 或 RWMutex 将被释放，其他

goroutine 可以获取锁并修改共享变量，但是当前 goroutine 仍然保持在等待队列中，直到收到唤醒信号。当

Wait 方法返回时，Mutex 或 RWMutex 会自动重新被锁定。

Wait 方法会阻塞当前的 goroutine，直到条件变量满足。在调用 Wait 方法之前，我们需要先获取锁，以确保条件

变量的正确使用。例如：

package main

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

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

func main() {
	go func() {
		time.Sleep(time.Second)
		mu.Lock()
		cond.Signal()
		mu.Unlock()
	}()
	mu.Lock()
	cond.Wait()
	fmt.Println("condition satisfied")
	mu.Unlock()
}

# 输出
condition satisfied

在上面的例子中，我们创建了一个 Mutex 类型的实例 mu 和一个 Cond 类型的实例 cond。在主 goroutine 中，

我们先获取了锁 mu，然后调用 cond.Wait() 方法等待条件变量的满足。在另一个 goroutine 中，我们等待 1 秒钟

后获取了锁 mu，然后调用 cond.Signal() 方法向等待的 goroutine 发送信号，表示条件变量已经满足。最后，我

们释放锁 mu。

需要注意的是，Wait 方法会自动释放锁，以便其他 goroutine 可以获取锁并修改条件变量。当 Wait 方法返回时，

它会重新获取锁，以便继续执行后续的代码。

7.6 Signal 唤醒一个协程

Signal 方法用于唤醒等待队列中的一个 goroutine，使其继续执行。在调用 Signal 方法之前，必须先获得 Mutex

或 RWMutex 的锁。

Signal 方法用于向等待的 goroutine 发送信号，表示条件变量已经满足。其定义如下：

func (c *Cond) Signal()

Signal 方法会选择一个等待的 goroutine 并唤醒它。如果没有等待的 goroutine，Signal 方法不会做任何事情。

7.7 Broadcast 广播唤醒所有

Broadcast 方法用于唤醒等待队列中的所有 goroutine，使它们继续执行。在调用 Broadcast 方法之前，必须先获

得 Mutex 或 RWMutex 的锁。

Broadcast 方法用于向所有等待的 goroutine 发送信号，表示条件变量已经满足。其定义如下：

func (c *Cond) Broadcast()

Broadcast 方法会唤醒所有等待的 goroutine。如果没有等待的 goroutine，Broadcast 方法不会做任何事情。

需要注意的是，Signal 和 Broadcast 方法只有在获取锁之后才能调用。否则，会导致 panic。

7.8 示例1

下面是一个使用 Cond 类型实现生产者-消费者模型的示例：

package main

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

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

func NewQueue() *Queue {
	q := &Queue{cond: sync.NewCond(&sync.Mutex{})}
	go func() {
		for {
			time.Sleep(time.Second)
			q.cond.L.Lock()
			q.items = append(q.items, rand.Intn(100))
			q.cond.Signal()
			q.cond.L.Unlock()
		}
	}()
	return q
}

func (q *Queue) Get() int {
	q.cond.L.Lock()
	for len(q.items) == 0 {
		q.cond.Wait()
	}
	item := q.items[0]
	q.items = q.items[1:]
	q.cond.L.Unlock()
	return item
}

func main() {
	q := NewQueue()
	for i := 0; i < 10; i++ {
		fmt.Println(q.Get())
	}
}

# 输出
81
87
47
59
81
18
25
40
56
0

在上面的例子中，我们定义了一个 Queue 类型，它包含一个 int 类型的切片 items 和一个 Cond 类型的实例

cond。在 NewQueue 函数中，我们启动了一个 goroutine，每秒钟向 items 中添加一个随机数，并调用

cond.Signal() 方法通知等待的 goroutine。在 Get 方法中，我们使用 cond.Wait() 方法等待 items 不为空，并返回

第一个元素。

7.9 示例2

package main

import (
	"log"
	"sync"
	"time"
)

var done = false

func read(name string, c *sync.Cond) {
	c.L.Lock()
	for !done {
		c.Wait()
	}
	log.Println(name, "starts reading")
	c.L.Unlock()
}

func write(name string, c *sync.Cond) {
	log.Println(name, "starts writing")
	time.Sleep(time.Second)
	c.L.Lock()
	done = true
	c.L.Unlock()
	log.Println(name, "wakes all")
	c.Broadcast()
}

func main() {
	cond := sync.NewCond(&sync.Mutex{})
	go read("reader1", cond)
	go read("reader2", cond)
	go read("reader3", cond)
	write("writer", cond)
	time.Sleep(time.Second * 3)
}

# 输出
2023/07/03 16:02:08 writer starts writing
2023/07/03 16:02:09 writer wakes all
2023/07/03 16:02:09 reader3 starts reading
2023/07/03 16:02:09 reader1 starts reading
2023/07/03 16:02:09 reader2 starts reading

• done 即互斥锁需要保护的条件变量。

• read() 调用 Wait() 等待通知，直到 done 为 true。

• write() 接收数据，接收完成后，将 done 置为 true，调用 Broadcast() 通知所有等待的协程。

• write() 中的暂停了 1s，一方面是模拟耗时，另一方面是确保前面的 3 个 read 协程都执行到 Wait()，处于等

  待状态。main 函数最后暂停了 3s，确保所有操作执行完毕。

7.10 注意事项

在使用 Cond 类型时，需要注意以下几点：

• 在调用 Wait 方法之前，必须先获取锁。否则，会导致 panic。

• Wait 方法会自动释放锁，以便其他 goroutine 可以获取锁并修改条件变量。当 Wait 方法返回时，它会重新获

  取锁，以便继续执行后续的代码。

• Signal 和 Broadcast 方法只有在获取锁之后才能调用。否则，会导致 panic。

• Signal 方法会选择一个等待的 goroutine 并唤醒它。如果没有等待的 goroutine，Signal 方法不会做任何事

  情。

• Broadcast 方法会唤醒所有等待的 goroutine。如果没有等待的 goroutine，Broadcast 方法不会做任何事

  情。

• 在使用 sync.Cond 前，一定要先创建一个互斥锁。

• 在调用 Wait 方法前，一定要先获取互斥锁，否则会导致死锁。

• 在调用 Wait 方法后，当前 goroutine 会被阻塞，直到被唤醒。

• 在调用 Signal 或 Broadcast 方法后，等待队列中的一个或多个 goroutine 会被唤醒，但不会立即获取互斥

  锁。因此，在使用 Signal 或 Broadcast 方法时，一定要保证唤醒的 goroutine 不会互相竞争同一个资源。

• 在调用 Signal 或 Broadcast 方法后，一定要释放互斥锁，否则被唤醒的 goroutine 无法获取到互斥锁，仍然

  会被阻塞。

• 在使用 sync.Cond 时，一定要注意竞争条件和数据同步的问题，确保程序的正确性和稳定性。

7.11 结语

在上面我们深入探讨了 sync.Cond 类型的使用方法和注意事项。我们学习了 Wait、Signal 和 Broadcast 方法的使

用，并通过一个生产者-消费者模型的示例来演示了 Cond 类型的实际应用。希望本文能够帮助你更好地理解 Go

语言中的并发编程。