锁
前言
在看今天的内容之前，我们先来看一个例子:
package main import ( "fmt" "math/rand" "sync" "time" ) func main() { var wait sync.WaitGroup wait.Add(10) count := 0 for i := 0; i < 10; i++ { go func(data *int) { time.Sleep(time.Millisecond * time.Duration(rand.Intn(5000))) //模拟实际耗时 temp := *data ans := 1 time.Sleep(time.Millisecond * time.Duration(rand.Intn(5000))) *data = temp + ans fmt.Println(*data) wait.Done() }(&count) } wait.Wait() fmt.Println(count) }
输出结果为:
1 1 2 2 2 2 2 3 2 2 2
这和我们预期的结果并不一致，这时因为count变量作为全局变量，在并行执行的时候
多个进程会同时访问该变量，可能一个协程还没有进行完,另一个协程已经对count的值
进行了修改，导致结果不正确。我们再看下面这个例子:
package main import ( "fmt" "sync" ) func main() { var wait sync.WaitGroup wait.Add(2) count := 0 go func() { defer wait.Done() for i := 0; i < 1000000; i++ { count++ } }() go func() { defer wait.Done() for i := 0; i < 1000000; i++ { count-- } }() wait.Wait() fmt.Println(count) }
运行这个代码时我们会发现与我们的预期的0不一致，它的值是随机的，原因和我们上面的例子一样，
那我们如何解决这个问题？这就是我们接下来要介绍的锁了。
互斥锁
互斥锁Mutex由sync包提供，它允许我们实现对共享资源的互斥访问，我们来看一个简单的例子:
package main import ( "fmt" "sync" ) func main() { var wait sync.WaitGroup var lock sync.Mutex wait.Add(2) count := 0 go func() { defer wait.Done() lock.Lock() //加锁 for i := 0; i < 1000000; i++ { count++ } lock.Unlock() }() go func() { defer wait.Done() lock.Lock() //解锁 for i := 0; i < 1000000; i++ { count-- } lock.Unlock() }() wait.Wait() fmt.Println(count) }
输出结果为:
0 • 1
与之前的例子不同，这次我们将加和减的操作都加上了锁，这样我们就可以保证共享变量
在完成加/减操作前都不会被其他协程访问到，从而避免了数据不一致的问题。每一个协
程在访问数据前，都先上锁，更新完成后再解锁，其他协程想要访问就 必须要先获得锁
否则就阻塞等待。如此一来，就不存在上述问题了。
读写锁
什么是读写锁
在介绍锁之前我们要先明确一件事情,我们要知道锁的本质其实是将原本并行的操作变成
串行操作，这样不可避免的会造成不必要的资源浪费，而在我们使用互斥锁的时候，如果
读写操作的数量趋于一致的时候，我们可以使用互斥锁，但是读写操作的数量差距较大时，
使用互斥锁将会造成大量的浪费，这时后我们就可以使用我们今天的主角——读写锁了。
对于一个协程而言:
- 获得读锁:当一个协程获得读锁时,其他协程进行写操作时会阻塞，其他协程进行读操
作时不会阻塞 - 获得写锁:当一个协程获得写锁时,其他协程进行写操作时会阻塞，其他协程进行读操作时
会阻塞
读写锁的相关方法
func(rw *sync.RWMutex) Rlock() // 读锁 func(rw *sync.RWMutex) Unlock() // 解锁 func(rw *sync.RWMutex) RUnlock() // 解锁 func(rw *sync.RWMutex) Lock() // 写锁 func(rw *sync.RWMutex) TryLock() bool // 尝试写锁 func(rw *sync.RWMutex) TryRLock() bool // 尝试读锁
读写锁的示例
package main import ( "fmt" "math/rand" "sync" "time" ) var wait sync.WaitGroup var rw sync.RWMutex var count = 0 func main() { wait.Add(12) go func() { for i := 0; i < 3; i++ { go Write(&count) } wait.Done() }() go func() { for i := 0; i < 7; i++ { go Read(&count) } wait.Done() }() // 等待子协程结束 wait.Wait() fmt.Println("最终结果", count) } func Read(count *int) { time.Sleep(time.Millisecond * time.Duration(rand.Intn(5000))) rw.RLock() fmt.Println("拿到读锁") time.Sleep(time.Millisecond * time.Duration(rand.Intn(5000))) fmt.Println("释放读锁") rw.RUnlock() defer wait.Done() } func Write(count *int) { time.Sleep(time.Millisecond * time.Duration(rand.Intn(5000))) rw.Lock() fmt.Println("拿到写锁") fmt.Println("拿到写锁") temp := *count time.Sleep(time.Millisecond * time.Duration(rand.Intn(1000))) *count = temp + 1 fmt.Println("释放写锁", *count) rw.Unlock() defer wait.Done() } • 51 • 52 • 53 • 54
输出
拿到读锁 拿到读锁 拿到读锁 拿到读锁 释放读锁 拿到读锁 释放读锁 释放读锁 释放读锁 释放读锁 拿到写锁 拿到写锁 释放写锁 1 拿到读锁 拿到读锁 释放读锁 释放读锁 拿到写锁 拿到写锁 释放写锁 2 拿到写锁 拿到写锁 释放写锁 3 最终结果 3 • 24
注意:对于锁而言，不应该将其作为值传递和存储，应该使用指针
条件变量
什么是条件变量
条件变量是一种用于协调并发程序中多个 goroutine 之间通信和同步的机制。它们通
常与互斥锁（Mutex）一起使用，用于在某些条件满足时唤醒等待的 goroutine。条件变量的作用包括：
- 等待条件满足： 条件变量允许一个或多个 goroutine 等待某个条件变为真（或满足特定条件）。这个条件可能涉及到共享资源的状态变化，比如某个变量的值改变、某个事件发生等。当条件未满足时，goroutine 可以通过条件变量进入等待状态。
- 唤醒等待的 goroutine： 当某个 goroutine 对共享资源做出修改，导致某个条件发生变化时，它可以通过条件变量来通知其他等待条件的 goroutine。这样，等待条件变为真的 goroutine 就可以被唤醒，继续执行相应的操作。
- 避免忙等待： 在并发程序中，如果没有条件变量，某些情况下可能会出现忙等待（busy waiting），即一个 goroutine 不断地检查某个条件是否满足，这会消耗大量的 CPU 资源。条件变量可以避免这种情况，因为它允许 goroutine 在条件不满足时进入休眠状态，直到条件变为真时才被唤醒。
- 同步 goroutine： 使用条件变量可以有效地同步多个 goroutine 的执行顺序，确保在适当的时机进行通信和处理共享资源，从而避免竞态条件和数据不一致的问题。
条件变量的组成
条件变量不是锁，它更像是是一种通信机制，在go中，条件变量由sync.Cond结构体表示，该结构体包含一个互斥锁和一个条件变量。
。它的函数签名如下:
//创建条件变量 func NewCond(l sync.Locker) *Cond // 阻塞等待条件生效，直到被唤醒 func (c *Cond) Wait() // 唤醒一个因条件阻塞的协程 func (c *Cond) Signal() // 唤醒所有因条件阻塞的协程 func (c *Cond) Broadcast()
在我们创建条件变量的时候，我们需要传递一个互斥锁，这里条件变量作用的是读协
程，所以将读锁作为互斥锁传入，如果直接传入读写互斥锁会导致写协程重复解锁的问
题。这里传入的是sync.rlocker，通过RWMutex.RLocker方法获得。
func (rw *RWMutex) RLocker() Locker { return (*rlocker)(rw) } type rlocker RWMutex func (r *rlocker) Lock() { (*RWMutex)(r).RLock() } func (r *rlocker) Unlock() { (*RWMutex)(r).RUnlock() }
我们来看一个简单的例子:
package main import ( "fmt" "math/rand" "sync" "time" ) var wait sync.WaitGroup var rw sync.RWMutex var count = 0 var cond = sync.NewCond(rw.RLocker()) func main() { wait.Add(12) for i := 0; i < 7; i++ { go func() { Read(&count) wait.Done() }() } for i := 0; i < 3; i++ { go func() { Write(&count) wait.Done() }() } wait.Wait() fmt.Println("最终结果:", count) } func Read(count *int) { time.Sleep(time.Millisecond * time.Duration(rand.Intn(5000))) fmt.Println("拿到读锁") rw.RLock() for *count < 3 { cond.Wait() } fmt.Println("读锁释放") rw.RUnlock() wait.Done() } func Write(count *int) { time.Sleep(time.Millisecond * time.Duration(rand.Intn(5000))) fmt.Println("拿到写锁") rw.Lock() temp := *count *count = temp + 1 fmt.Println("写锁释放", *count) rw.Unlock() cond.Broadcast() wait.Done() }
输出结果:
拿到读锁 拿到写锁 写锁释放 1 拿到写锁 写锁释放 2 拿到写锁 写锁释放 3 读锁释放 拿到读锁 读锁释放 拿到读锁 读锁释放 最终结果: 3
注意:
对于条件变量，应该使用for而不是if，应该使用循环来判断条件是否满足，因为协程被唤醒时并不能保证当前条件就已经满足了。
for *count < 3 { cond.Wait() }
