Golang中的锁机制

news2025/1/11 5:28:51

在Go语言中，处理并发问题时通常优先考虑使用信道（channel），但在某些情况下，当信道无法解决问题时，就需要使用锁机制来处理共享内存的并发访问。Go语言提供了两种主要的锁类型：互斥锁（Mutex）和读写锁（RWMutex）。

1. 互斥锁（Mutex）

互斥锁用于保护资源，防止并发操作引起的冲突和数据不准确。在Go中，可以通过sync.Mutex来实现互斥锁。例如，以下代码展示了如何使用互斥锁来保护一个计数器的并发访问：

package main

import (
"fmt"
"sync"
)

func add(count *int, wg *sync.WaitGroup, lock *sync.Mutex) {
for i := 0; i < 1000; i++ {
lock.Lock()
*count = *count + 1
lock.Unlock()
}
wg.Done()
}

func main() {
var wg sync.WaitGroup
lock := &sync.Mutex{}
count := 0
wg.Add(3)
go add(&count, &wg, lock)
go add(&count, &wg, lock)
go add(&count, &wg, lock)

wg.Wait()
fmt.Println("count 的值为：", count)
}

在使用互斥锁时，需要注意以下几点：

同一协程内，不要在未解锁前再次加锁。
同一协程内，不要对已解锁的锁再次解锁。
加锁后，记得解锁，必要时使用defer语句。

2. 读写锁（RWMutex）

sync.RWMutex 是 Go 标准库提供的一种读写锁机制,它可以用于保护共享资源的线程安全访问。

读写锁允许多个读操作并发进行，而写操作会阻塞所有读写操作。这种锁机制可以提高程序的效率，特别是在读操作远多于写操作的场景中。

1. 原理解释:

sync.RWMutex 分为两种锁:读锁和写锁。
当一个 goroutine 持有读锁时,其他 goroutine 可以同时获取读锁,但不能获取写锁。
当一个 goroutine 持有写锁时,其他 goroutine 既不能获取读锁也不能获取写锁,直到该写锁被释放。

2. 使用方法:

r.RLock()/r.RUnlock(): 获取和释放读锁。
r.Lock()/r.Unlock(): 获取和释放写锁。
通常在读取共享资源时使用 RLock()/RUnlock(),在写入共享资源时使用 Lock()/Unlock(),以提高并发性能。

3.示例展示：

type TemplateTSMap[TK comparable, TV any] struct {
M map[TK]TV
lock sync.RWMutex
}

在如上TemplateTSMap结构体中的应用；

在 TemplateTSMap 结构体中,我们使用 sync.RWMutex 来保护 M 字段(即底层的 map)。
当一个 goroutine 需要读取 map 中的数据时,它会获取读锁(RLock())。这样可以允许其他 goroutine 同时读取数据,提高并发性能。
当一个 goroutine 需要写入或删除 map 中的数据时,它会获取写锁(Lock())。这样可以确保在写入过程中不会有其他 goroutine 读取或修改数据,保证数据的一致性。
在读取或写入操作完成后,goroutine 需要相应地释放读锁(RUnlock())或写锁(Unlock())。

以下是一个使用读写锁的示例：

package main

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

func main() {
lock := &sync.RWMutex{}
lock.Lock()

for i := 0; i < 4; i++ {
go func(i int) {
fmt.Printf("第 %d 个协程准备开始... \n", i)
lock.RLock()
fmt.Printf("第 %d 个协程获得读锁, sleep 1s 后，释放锁\n", i)
time.Sleep(time.Second)
lock.RUnlock()
}(i)
}

time.Sleep(time.Second * 2)

fmt.Println("准备释放写锁，读锁不再阻塞")
lock.Unlock()

lock.Lock()
fmt.Println("程序退出...")
lock.Unlock()
}

在使用读写锁时，应当注意以下几点：