Go语言Sync包

这篇具有很好参考价值的文章主要介绍了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

语言中的并发编程。文章来源地址https://www.toymoban.com/news/detail-591169.html

到了这里,关于Go语言Sync包的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Golang】VScode配置Go语言环境

    安装VScode请参考我的上一篇博客:VScode安装_㫪548的博客-CSDN博客 接下来我们直接进入正题: Go语言(又称Golang)是一种开源的编程语言,由Google开发并于2009年首次发布。Go语言具有简洁、高效、可靠和易于阅读的特点,被设计用于解决大型项目的开发需求。它结合了静态类型

    2024年02月03日
    浏览(66)
  • 【GoLang】MAC安装Go语言环境

    小试牛刀 首先安装VScode软件 或者pycharm mac安装brew软件  brew install go 报了一个错误 不提供这个支持  重新brew install go 之后又重新brew reinstall go 使用go version 可以看到go 的版本 使用go env  可以看到go安装后的配置 配置一个环境变量 vim ~/.zshrc,  

    2024年02月15日
    浏览(59)
  • Go语言(Golang)数据库编程

    要想连接到 SQL 数据库,首先需要加载目标数据库的驱动,驱动里面包含着于该数据库交互的逻辑。 sql.Open() 数据库驱动的名称 数据源名称 得到一个指向 sql.DB 这个 struct 的指针 sql.DB 是用来操作数据库的,它代表了0个或者多个底层连接的池,这些连接由sql 包来维护,sql 包会

    2024年02月03日
    浏览(92)
  • 【Golang】Golang进阶系列教程--Go 语言 map 如何顺序读取?

    Go 语言中的 map 是一种非常强大的数据结构,它允许我们快速地存储和检索键值对。 然而,当我们遍历 map 时,会有一个有趣的现象,那就是输出的键值对顺序是不确定的。 先看一段代码示例: 当我们多执行几次这段代码时,就会发现,输出的顺序是不同的。 首先,Go 语言

    2024年02月14日
    浏览(68)
  • 【Golang】Golang进阶系列教程--Go 语言数组和切片的区别

    在 Go 语言中,数组和切片看起来很像,但其实它们又有很多的不同之处,这篇文章就来说说它们到底有哪些不同。 数组和切片是两个常用的数据结构。它们都可以用于存储一组相同类型的元素,但在底层实现和使用方式上存在一些重要的区别。 Go 中数组的长度是不可改变的

    2024年02月15日
    浏览(60)
  • 【Golang】Golang进阶系列教程--Go 语言切片是如何扩容的?

    在 Go 语言中,有一个很常用的数据结构,那就是切片(Slice)。 切片是一个拥有相同类型元素的可变长度的序列,它是基于数组类型做的一层封装。它非常灵活,支持自动扩容。 切片是一种引用类型,它有三个属性:指针,长度和容量。 底层源码定义如下: 指针: 指向

    2024年02月14日
    浏览(69)
  • 【Golang】三分钟让你快速了解Go语言&为什么我们需要Go语言?

    博主简介: 努力学习的大一在校计算机专业学生,热爱学习和创作。目前在学习和分享:数据结构、Go,Java等相关知识。 博主主页: @是瑶瑶子啦 所属专栏: Go语言核心编程 近期目标: 写好专栏的每一篇文章 Go 语言从 2009 年 9 月 21 日开始作为谷歌公司 20% 兼职项目,即相关

    2023年04月21日
    浏览(61)
  • Golang(Go语言)IP地址转换函数

    String形式的IP地址和Int类型互转函数 代码 输出如下:  

    2024年02月05日
    浏览(53)
  • 【GoLang】哪些大公司正在使用Go语言

    前言: 随着计算机科学和软件开发的快速发展,编程语言的选择变得愈加关键。 在这个多元化的编程语境中,Go语言(简称Golang)以其简洁、高效、并发处理能力等特性逐渐受到业界关注。 越来越多的大型科技公司纷纷采用Go语言作为其软件开发的首选语言,这种趋势反映了

    2024年02月04日
    浏览(65)
  • Golang区块链钱包_go语言钱包

    Golang区块链钱包的特点 Golang区块链钱包具有以下几个特点: 1. 高性能 Golang是一种编译型语言,具有快速的执行速度和较低的内存消耗。这使得Golang区块链钱包在处理大规模交易数据时表现出色,能够满足高性能的需求。 2. 并发支持 Golang内置了轻量级线程——goroutine,以及

    2024年04月15日
    浏览(62)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包