千家信息网

golang中锁的使用场景主要涉及到哪些呢

发表于:2024-11-16 作者:千家信息网编辑
千家信息网最后更新 2024年11月16日,golang中锁的使用场景主要涉及到哪些呢,针对这个问题,这篇文章详细介绍了相对应的分析和解答,希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。一、什么场景下需要用到锁当程序中就一个线程的
千家信息网最后更新 2024年11月16日golang中锁的使用场景主要涉及到哪些呢

golang中锁的使用场景主要涉及到哪些呢,针对这个问题,这篇文章详细介绍了相对应的分析和解答,希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。

一、什么场景下需要用到锁

当程序中就一个线程的时候,是不需要加锁的,但是通常实际的代码不会只是单线程,有可能是多个线程同时访问公共资源,所以这个时候就需要用到锁了,那么关于锁的使用场景主要涉及到哪些呢?

1. 多个线程在读相同的数据时
2. 多个线程在写相同的数据时
3. 同一个资源,有读又有写时

二、Go 锁分为两种:

  • 互斥锁 (sync.Mutex)

  • 读写锁 (sync.RWMutex 底层依赖Mutex实现 )

互斥锁是并发程序对公共资源访问限制最常见的方式。在Go中,sync.Mutex 提供了互斥锁的实现。

当一个goroutine获得了Mutex后,其他goroutine只能等待,除非该goroutine释放这个Mutex。

互斥锁结构:

type Mutex struct {    state int32    sema  uint32}

1. 锁定状态值为1,未锁定状态锁为 0 。

2. Lock()加锁、Unlock解锁。

读写锁则是对读写操作进行加锁。需要注意的是多个读操作之间不存在互斥关系,这样提高了对共享资源的访问效率。

Go中读写锁由 sync.RWMutex 提供,RWMutex在读锁占用的情况下,会阻止写,但不阻止读。RWMutex在写锁占用情况下,会阻止任何其他goroutine(无论读和写)进来,整个锁相当于由该goroutine独占。

读写锁结构:

type RWMutex struct {    w           Mutex  // held if there are pending writers    writerSem   uint32 // semaphore for writers to wait for completing readers    readerSem   uint32 // semaphore for readers to wait for completing writers    readerCount int32  // number of pending readers    readerWait  int32  // number of departing readers}

1. RWMutex是单写多读锁,该锁可以加多个读锁或者一个写锁。

2. 读锁占用的情况会阻止写,不会阻止读,多个goroutine可以同时获取读锁。

3. 写锁会阻止其他gorotine不论读或者写进来,整个锁由写锁goroutine占用 与第一条共用示范代码

4. 适用于读多写少的场景


三、如何使用互斥锁

Mutex为互斥锁,Lock() 加锁,Unlock() 解锁,使用Lock() 加锁后,便不能再次对其进行加锁,直到利用Unlock()解锁对其解锁后,才能再次加锁.适用于读写不确定场景,即读写次数没有明显的区别,并且只允许只有一个读或者写的场景,所以该锁叶叫做全局锁。

互斥锁只能锁定一次,当在解锁之前再次进行加锁,便会无法加锁。如果在加锁前解锁,便会报错"panic: sync: unlock of unlocked mutex"。

package mainimport ("fmt"    "sync")
var ( count int lock sync.Mutex)
func main() { for i := 0; i < 2; i++ { go func() { for i := 1000000; i > 0; i-- { lock.Lock() count ++ lock.Unlock() } fmt.Println(count) }() }
fmt.Scanf("\n") //等待子线程全部结束}
运行结果:19525332000000 //最后的线程打印输出

对于上面的程序,a作为一个公共的资源,所以对a的改变、读写等操作都需要加锁。

需要注意的问题:

  1. 不要重复锁定互斥锁
  2. 不要忘记解锁互斥锁,必要时使用 defer 语句
  3. 不要在多个函数之间直接传递互斥锁

四、如何使用读写锁

读写锁的场景主要是在多线程的安全操作下,并且读的情况多于写的情况,也就是说既满足多线程操作的安全性,也要确保性能不能太差,这时候,我们可以考虑使用读写锁。当然你也可以简单暴力直接使用互斥锁(Mutex)。

Lock() 写锁,如果在添加写锁之前已经有其他的读锁和写锁,则lock就会阻塞直到该锁可用,为确保该锁最终可用,已阻塞的 Lock 调用会从获得的锁中排除新的读取器,即写锁权限高于读锁,有写锁时优先进行写锁定。

Unlock() 写锁解锁,如果没有进行写锁定,则就会引起一个运行时错误。

RLock() 读锁,当有写锁时,无法加载读锁,当只有读锁或者没有锁时,可以加载读锁,读锁可以加载多个,所以适用于"读多写少"的场景。

RUnlock() 读锁解锁,RUnlock 撤销单次RLock 调用,它对于其它同时存在的读取器则没有效果。若 rw 并没有为读取而锁定,调用 RUnlock 就会引发一个运行时错误。

package mainimport ("fmt"    "sync")
var ( count int rwLock sync.RWMutex)
func main() { for i := 0; i < 2; i++ { go func() { for i := 1000000; i > 0; i-- { rwLock.Lock() count ++ rwLock.Unlock() } fmt.Println(count) }() }
fmt.Scanf("\n") //等待子线程全部结束}
运行结果:19686372000000

看着挺复杂的,其实简单来说就是:

  1. 读锁不能阻塞读锁

  2. 读锁需要阻塞写锁,直到所有读锁都释放

  3. 写锁需要阻塞读锁,直到所有写锁都释放

  4. 写锁需要阻塞写锁

关于golang中锁的使用场景主要涉及到哪些呢问题的解答就分享到这里了,希望以上内容可以对大家有一定的帮助,如果你还有很多疑惑没有解开,可以关注行业资讯频道了解更多相关知识。

0