图解golang读写锁RWMutex

大家好,我是Anthony_4926。

欢迎访问飞书版本:cnl25x1hkc.feishu.cn/docx/Z6KtdW...

我们先明确一些概念

RWMutex涉及到两个操作:读操作、写操作。请严格区分操作的概念。

在接下来的代码解析过程中,可以发现只有写操作是真正的会加锁,而读操作是不加锁的。

还需要区分写操作拥有锁 ,和拥有写权限的区别。再次强调只有写操作会加锁,但是,即便是写操作拥有了锁,还需要根据当前是否有读操作正在进行读,来判断写操作是否具有写权限。

读操作会阻塞写操作,使之无法获得写权限。

可能上边的内容会让你有点懵,没关系,向下看就好。

锁结构

go 复制代码
type RWMutex struct {
   w           Mutex  // 互斥锁,控制多个写入操作的并发执行
   writerSem   uint32 // 写入操作的信号量
   readerSem   uint32 // 读操作的信号量
   readerCount int32  // 当前读操作的个数
   readerWait  int32  // 当前写入操作需要等待读操作解锁的个数
}
  • w是用来给给读写锁中的写操作申请锁用的,读操作并不会上锁,只是会阻塞写锁写而已。

  • 接下来是两个信号量。为了便于理解,我们将加锁过程简单化,认为协程加锁不成功就会被阻塞,休眠。

    • writerSem:如果写操作加锁不成功,就会将写操作休眠,加入与writerSem关联的休眠队列,等writerSem改变时,如果满足条件,则唤醒一个休眠队列中的写操作。
    • readerSem:如果读操作加锁不成功,就会将读操作休眠,加入到与readerSem关联的休眠队列,等readerSem改变时,如果满足条件,则唤醒休眠的读操作。
  • 最后两个是读操作计数,只不过记录的内容不一样。

    • readerCount:记录的是当前读操作的个数
    • readerWait:记录的是当前写操作需要等待读操作的个数。如上图,写操作得等待它上边的是哪个读操作结束。需要注意的是,同一时间只能有一个写操作来抢锁。

获取写锁

scss 复制代码
func (rw *RWMutex) Lock() {
   if race.Enabled {
      _ = rw.w.state
      race.Disable()
   }
   // 第一个写操作先锁住,此时就会阻塞其他写锁,至于能否获得读的权限,还得看是否有读锁需要等待
   rw.w.Lock()
   // rwmutexMaxReaders = 1 << 30
   // 将readerCount设置为极小的值,是为了标记当前有写操作,已经加写锁成功,等待获得写权限
   // 先对readerCount减是为了是为了标记当前有写操作,已经加写锁成功,等待获得写权限
   // 再加回来,是为了获得readerCount的数量
   r := atomic.AddInt32(&rw.readerCount, -rwmutexMaxReaders) + rwmutexMaxReaders
   // 如果readerCount不等于0,说明之前有读操作,那就应该将readerWait加上r
   // 表示当前写操作需要休眠,等待readerWait个读操作后被唤醒,获得写权限
   if r != 0 && atomic.AddInt32(&rw.readerWait, r) != 0 {
      runtime_SemacquireMutex(&rw.writerSem, false)
   }
   if race.Enabled {
      race.Enable()
      race.Acquire(unsafe.Pointer(&rw.readerSem))
      race.Acquire(unsafe.Pointer(&rw.writerSem))
   }
}

关于竞态检测的内容我们可以先不用理会。接下来我们捋一捋Lock()流程。

假设,当前各种操作的状态是下图左边这个样子滴,然后有个协程申请Lock(),于是变成右边

第一个写操作先获得锁,此时就会阻塞其他写锁,至于能否获得写操权限,还得看是否有读锁需要等待。

Lock()将readerCount设置为极小的值,是为了标记当前有写操作,已经拥有锁,等待获得写权限。再加回来,是为了获得readerCount的数量。接下来就是判断能否获得写操作权限的逻辑。

如果readerCount不等于0,说明之前有读操作,那就应该将readerWait加上r 表示当前写操作需要休眠,等待readerWait个读操作后被唤醒,获得写权限

获取读锁

scss 复制代码
func (rw *RWMutex) RLock() {
   if race.Enabled {
      _ = rw.w.state
      race.Disable()
   }
   // 如果readerCount+1小于0,表示曾经被置为非常小
   // 即,当前有写操作获取了锁。所以,当前读操作需要阻塞休眠,与readerSem进行关联
   if atomic.AddInt32(&rw.readerCount, 1) < 0 {
      runtime_SemacquireMutex(&rw.readerSem, false)
   }
   if race.Enabled {
      race.Enable()
      race.Acquire(unsafe.Pointer(&rw.readerSem))
   }
}

获取写锁时说过,写操作获得锁后,会将readerCount置为一个非常小的数,因此这里如果readerCount+1小于0,则表示,有写操作已经获得锁,当前读操作需要阻塞休眠,并将该协程与readerSem进行关联。

当前状态可以是下图这样

释放读锁

scss 复制代码
func (rw *RWMutex) RUnlock() {
   if race.Enabled {
      _ = rw.w.state
      race.ReleaseMerge(unsafe.Pointer(&rw.writerSem))
      race.Disable()
   }
   // 读操作加锁时,是给readerCount加1,释放锁时,是给readerCount减1
   // 减完后,仍然小于0, 表示当前是有写操作获取了锁滴,而且正在阻塞。
   if r := atomic.AddInt32(&rw.readerCount, -1); r < 0 {
      // 异常情况判断,不影响整体流程。略过
      if r+1 == 0 || r+1 == -rwmutexMaxReaders {
         race.Enable()
         throw("sync: RUnlock of unlocked RWMutex")
      }
      // 如果给readerCount减1后,仍然小于0,说明有写操作在阻塞
      // 应该给readerWait再减1,等readerWait为0时,说明,可以唤醒写操作了
      if atomic.AddInt32(&rw.readerWait, -1) == 0 {
         runtime_Semrelease(&rw.writerSem, false)
      }
   }
   if race.Enabled {
      race.Enable()
   }
}

读操作加锁时,是给readerCount加1,释放锁时,是给readerCount减1。

减完后,仍然小于0, 表示当前是有写操作获取了锁滴,而且正在阻塞。

有写操作阻塞的话,应该给readerWait再减1,等readerWait为0时,说明,可以唤醒写操作了。

如下图,写操作在获取锁时,readerWait的数量是3,等这三个读操作都结束后,写操作就可以执行了。所以,需要唤醒写操作。你可以自己观察一下代码,唤醒和阻塞调用的是不一样的runtime方法。

释放写锁

scss 复制代码
func (rw *RWMutex) Unlock() {
   if race.Enabled {
      _ = rw.w.state
      race.Release(unsafe.Pointer(&rw.readerSem))
      race.Disable()
   }

   // 加写锁时,给readerCount减了一个很大的数,释放时再将这个数加回来
   r := atomic.AddInt32(&rw.readerCount, rwmutexMaxReaders)
   // 异常情况判断,不影响整体流程。略过
   if r >= rwmutexMaxReaders {
      race.Enable()
      throw("sync: Unlock of unlocked RWMutex")
   }
   // 写操作结束后,唤醒读操作。可以看到,这个地方唤醒读操作唤醒了r次
   for i := 0; i < int(r); i++ {
      runtime_Semrelease(&rw.readerSem, false)
   }
   // 读操作释放读锁
   rw.w.Unlock()
   if race.Enabled {
      race.Enable()
   }
}

加写锁时,给readerCount减了一个很大的数,释放时再将这个数加回来。

写操作结束后,唤醒读操作。可以看到,这个地方唤醒读操作唤醒了r次。还是用下边这个图解释一下

相关推荐
郑祎亦20 分钟前
Spring Boot 项目 myblog 整理
spring boot·后端·java-ee·maven·mybatis
本当迷ya32 分钟前
💖2025年不会Stream流被同事排挤了┭┮﹏┭┮(强烈建议实操)
后端·程序员
计算机毕设指导61 小时前
基于 SpringBoot 的作业管理系统【附源码】
java·vue.js·spring boot·后端·mysql·spring·intellij-idea
paopaokaka_luck2 小时前
[371]基于springboot的高校实习管理系统
java·spring boot·后端
捂月3 小时前
Spring Boot 深度解析:快速构建高效、现代化的 Web 应用程序
前端·spring boot·后端
煎鱼eddycjy3 小时前
新提案:由迭代器启发的 Go 错误函数处理
go
煎鱼eddycjy3 小时前
Go 语言十五周年!权力交接、回顾与展望
go
瓜牛_gn3 小时前
依赖注入注解
java·后端·spring
Estar.Lee4 小时前
时间操作[取当前北京时间]免费API接口教程
android·网络·后端·网络协议·tcp/ip
喜欢猪猪4 小时前
Django:从入门到精通
后端·python·django