深入理解 go RWMutex

简介: 深入理解 go RWMutex

前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家。点击跳转到网站。

在上一篇文章《深入理解 go Mutex》中,

我们已经对 go Mutex 的实现原理有了一个大致的了解,也知道了 Mutex 可以实现并发读写的安全。

今天,我们再来看看另外一种锁,RWMutex,有时候,其实我们读数据的频率要远远高于写数据的频率,

而且不同协程应该可以同时读取的,这个时候,RWMutex 就派上用场了。

RWMutex 的实现原理和 Mutex 类似,只是在 Mutex 的基础上,区分了读锁和写锁:

  • 读锁:只要没有写锁,就可以获取读锁,多个协程可以同时获取读锁(可以并行读)。
  • 写锁:只能有一个协程获取写锁,其他协程想获取读锁或写锁都只能等待。

下面就让我们来深入了解一下 RWMutex 的基本使用和实现原理等内容。

RWMutex 的整体模型

正如 RWMutex 的命名那样,它是区分了读锁和写锁的锁,所以我们可以从读和写两个方面来看 RWMutex 的模型。

下文中的 reader 指的是进行读操作的 goroutine,writer 指的是进行写操作的 goroutine。

读操作模型

我们可以用下图来表示 RWMutex 的读操作模型:

上图使用了 w.Lock,是因为 RWMutex 的实现中,写锁是使用 Mutex 来实现的。

说明:

  • 读操作的时候可以同时有多个 goroutine 持有 RLock,然后进入临界区。(也就是可以并行读),上图的 G1、G2 和 G3 就是同时持有 RLock 的几个 goroutine。
  • 在读操作的时候,如果有 goroutine 持有 RLock,那么其他 goroutine (不管是读还是写)就只能等待,直到所有持有 RLock 的 goroutine 释放锁。
  • 也就是上图的 G4 需要等待 G1、G2 和 G3 释放锁之后才能进入临界区。
  • 最后,因为 G5 和 G6 这两个协程获取锁的时机比 G4 晚,所以它们会在 G4 释放锁之后才能进入临界区。

写操作模型

我们可以用下图来表示 RWMutex 的写操作模型:

说明:

  • 写操作的时候只能有一个 goroutine 持有 Lock,然后进入临界区,释放写锁之前,所有其他的 goroutine 都只能等待。
  • 上图的 G1~G5 表示的是按时间顺序先后获取锁的几个 goroutine。
  • 上面几个 goroutine 获取锁的过程是:
  • G1 获取写锁,进入临界区。然后 G2、G3、G4 和 G5 都在等待。
  • G1 释放写锁之后,G2 和 G3 可以同时获取读锁,进入临界区。然后 G3、G4 和 G5 都在等待。
  • G2 和 G3 可以同时获取读锁,进入临界区。然后 G4 和 G5 都在等待。
  • G2 和 G3 释放读锁之后,G4 获取写锁,进入临界区。然后 G5 在等待。
  • 最后,G4 释放写锁,G5 获取读锁,进入临界区。

基本用法

RWMutex 中包含了以下的方法:

  • Lock:获取写锁,如果有其他 goroutine 持有读锁或写锁,那么就会阻塞等待。
  • Unlock:释放写锁。
  • RLock:获取读锁,如果有其他 goroutine 持有写锁,那么就会阻塞等待。
  • RUnlock:释放读锁。

其他不常用的方法:

  • RLocker:返回一个读锁,该锁包含了 RLock 和 RUnlock 方法,可以用来获取读锁和释放读锁。
  • TryLock: 尝试获取写锁,如果获取成功,返回 true,否则返回 false。不会阻塞等待。
  • TryRLock: 尝试获取读锁,如果获取成功,返回 true,否则返回 false。不会阻塞等待。

一个简单的例子

我们可以通过下面的例子来看一下 RWMutex 的基本用法:

package mutex
import (
  "sync"
  "testing"
)
var config map[string]string
var mu sync.RWMutex
func TestRWMutex(t *testing.T) {
  config = make(map[string]string)
  // 启动 10 个 goroutine 来写
  var wg1 sync.WaitGroup
  wg1.Add(10)
  for i := 0; i < 10; i++ {
    go func() {
      set("foo", "bar")
      wg1.Done()
    }()
  }
  // 启动 100 个 goroutine 来读
  var wg2 sync.WaitGroup
  wg2.Add(100)
  for i := 0; i < 100; i++ {
    go func() {
      get("foo")
      wg2.Done()
    }()
  }
  wg1.Wait()
  wg2.Wait()
}
// 获取配置
func get(key string) string {
  // 获取读锁,可以多个 goroutine 并发读取
  mu.RLock()
  defer mu.RUnlock()
  if v, ok := config[key]; ok {
    return v
  }
  return ""
}
// 设置配置
func set(key, val string) {
  // 获取写锁
  mu.Lock()
  defer mu.Unlock()
  config[key] = val
}

上面的例子中,我们启动了 10 个 goroutine 来写配置,启动了 100 个 goroutine 来读配置。

这跟我们现实开发中的场景是一样的,很多时候其实是读多写少的。

如果我们在读的时候也使用互斥锁,那么就会导致读的性能非常差,因为读操作一般都不会有副作用的,但是如果使用互斥锁,那么就只能一个一个的读了。

而如果我们使用 RWMutex,那么就可以同时有多个 goroutine 来读取配置,这样就可以大大提高读的性能。

因为我们进行读操作的时候,可以多个 goroutine 并发读取,这样就可以大大提高读的性能。

RWMutex 使用的注意事项

在《深入理解 go Mutex》中,我们已经讲过了 Mutex 的使用注意事项,

其实 RWMutex 的使用注意事项也是差不多的:

  • 不要忘记释放锁,不管是读锁还是写锁。
  • Lock 之后,没有释放锁之前,不能再次使用 Lock。
  • 在 Unlock 之前,必须已经调用了 Lock,否则会 panic
  • 在第一次使用 RWMutex 之后,不能复制,因为这样一来 RWMutex 的状态也会被复制。这个可以使用 go vet 来检查。

源码剖析

RWMutex 的一些实现原理跟 Mutex 是一样的,比如阻塞的时候使用信号量等,在 Mutex 那一篇中已经有讲解了,这里不再赘述。

这里就 RWMutex 的实现原理进行一些简单的剖析。

RWMutex 结构体

RWMutex 的结构体定义如下:

type RWMutex struct {
  w           Mutex        // 互斥锁,用于保护读写锁的状态
  writerSem   uint32       // writer 信号量
  readerSem   uint32       // reader 信号量
  readerCount atomic.Int32 // 所有 reader 数量
  readerWait  atomic.Int32 // writer 等待完成的 reader 数量
}

各字段含义:

  • w:互斥锁,用于保护读写锁的状态。RWMutex 的写锁是互斥锁,所以直接使用 Mutex 就可以了。
  • writerSem:writer 信号量,用于实现写锁的阻塞等待。
  • readerSem:reader 信号量,用于实现读锁的阻塞等待。
  • readerCount:所有 reader 数量(包括已经获取读锁的和正在等待获取读锁的 reader)。
  • readerWait:writer 等待完成的 reader 数量(也就是获取写锁的时刻,已经获取到读锁的 reader 数量)。

因为要区分读锁和写锁,所以在 RWMutex 中,我们需要两个信号量,一个用于实现写锁的阻塞等待,一个用于实现读锁的阻塞等待。

我们需要特别注意的是 readerCount 和 readerWait 这两个字段,我们可能会比较好奇,为什么有了 readerCount 这个字段,

还需要 readerWait 这个字段呢?

这是因为,我们在尝试获取写锁的时候,可能会有多个 reader 正在使用读锁,这时候我们需要知道有多少个 reader 正在使用读锁,

等待这些 reader 释放读锁之后,就获取写锁了,而 readerWait 这个字段就是用来记录这个数量的。

在 Lock 中获取写锁的时候,如果观测到 readerWait 不为 0 则会阻塞等待,直到 readerWait 为 0 之后才会真正获取写锁,然后才可以进行写操作。

读锁源码剖析

获取读锁的方法如下:

// 获取读锁
func (rw *RWMutex) RLock() {
  if rw.readerCount.Add(1) < 0 {
    // 有 writer 在使用锁,阻塞等待 writer 完成
    runtime_SemacquireRWMutexR(&rw.readerSem, false, 0)
  }
}

读锁的实现很简单,先将 readerCount 加 1,如果加 1 之后的值小于 0,说明有 writer 正在使用锁,那么就需要阻塞等待 writer 完成。

释放读锁的方法如下:

// 释放读锁
func (rw *RWMutex) RUnlock() {
  // readerCount 减 1,如果 readerCount 小于 0 说明有 writer 在等待
  if r := rw.readerCount.Add(-1); r < 0 {
    // 有 writer 在等待,唤醒 writer
    rw.rUnlockSlow(r)
  }
}
// 唤醒 writer
func (rw *RWMutex) rUnlockSlow(r int32) {
  // 未 Lock 就 Unlock,panic
  if r+1 == 0 || r+1 == -rwmutexMaxReaders {
    fatal("sync: RUnlock of unlocked RWMutex")
  }
  // readerWait 减 1,返回值是新的 readerWait 值
  if rw.readerWait.Add(-1) == 0 {
    // 最后一个 reader 唤醒 writer
    runtime_Semrelease(&rw.writerSem, false, 1)
  }
}

读锁的实现总结:

  • 获取读锁的时候,会将 readerCount 加 1
  • 如果正在获取读锁的时候,发现 readerCount 小于 0,说明有 writer 正在使用锁,那么就需要阻塞等待 writer 完成。
  • 释放读锁的时候,会将 readerCount 减 1
  • 如果 readerCount 减 1 之后小于 0,说明有 writer 正在等待,那么就需要唤醒 writer。
  • 唤醒 writer 的时候,会将 readerWait 减 1,如果 readerWait 减 1 之后为 0,说明 writer 获取锁的时候存在的 reader 都已经释放了读锁,可以获取写锁了。

·rwmutexMaxReaders算是一个特殊的标识,在获取写锁的时候会将readerCount的值减去rwmutexMaxReaders, 所以在其他地方可以根据 readerCount` 是否小于 0 来判断是否有 writer 正在使用锁。

写锁源码剖析

获取写锁的方法如下:

// 获取写锁
func (rw *RWMutex) Lock() {
  // 首先,解决与其他写入者的竞争。
  rw.w.Lock()
  // 向读者宣布有一个待处理的写入。
  // r 就是当前还没有完成的读操作,等这部分读操作完成之后才可以获取写锁。
  r := rw.readerCount.Add(-rwmutexMaxReaders) + rwmutexMaxReaders
  // 等待活跃的 reader
  if r != 0 && rw.readerWait.Add(r) != 0 {
    // 阻塞,等待最后一个 reader 唤醒
    runtime_SemacquireRWMutex(&rw.writerSem, false, 0)
  }
}

释放写锁的方法如下:

// 释放写锁
func (rw *RWMutex) Unlock() {
  // 向 readers 宣布没有活动的 writer。
  r := rw.readerCount.Add(rwmutexMaxReaders)
  if r >= rwmutexMaxReaders { // r >= 0 并且 < rwmutexMaxReaders 才是正常的(r 是持有写锁期间尝试获取读锁的 reader 数量)
    fatal("sync: Unlock of unlocked RWMutex")
  }
  // 如果有 reader 在等待写锁释放,那么唤醒这些 reader。
  for i := 0; i < int(r); i++ {
    runtime_Semrelease(&rw.readerSem, false, 0)
  }
  // 允许其他的 writer 继续进行。
  rw.w.Unlock()
}

写锁的实现总结:

  • 获取写锁的时候,会将 readerCount 减去 rwmutexMaxReaders,这样就可以区分读锁和写锁了。
  • 如果 readerCount 减去 rwmutexMaxReaders 之后不为 0,说明有 reader 正在使用读锁,那么就需要阻塞等待这些 reader 释放读锁。
  • 释放写锁的时候,会将 readerCount 加上 rwmutexMaxReaders。
  • 如果 readerCount 加上 rwmutexMaxReaders 之后大于 0,说明有 reader 正在等待写锁释放,那么就需要唤醒这些 reader。

TryRLock 和 TryLock

TryRLock 和 TryLock 的实现都很简单,都是尝试获取读锁或者写锁,如果获取不到就返回 false,获取到了就返回 true,这两个方法不会阻塞等待。

// TryRLock 尝试锁定 rw 以进行读取,并报告是否成功。
func (rw *RWMutex) TryRLock() bool {
  for {
    c := rw.readerCount.Load()
    // 有 goroutine 持有写锁
    if c < 0 {
      return false
    }
    // 尝试获取读锁
    if rw.readerCount.CompareAndSwap(c, c+1) {
      return true
    }
  }
}
// TryLock 尝试锁定 rw 以进行写入,并报告是否成功。
func (rw *RWMutex) TryLock() bool {
  // 写锁被占用
  if !rw.w.TryLock() {
    return false
  }
  // 读锁被占用
  if !rw.readerCount.CompareAndSwap(0, -rwmutexMaxReaders) {
    // 释放写锁
    rw.w.Unlock()
    return false
  }
  // 成功获取到锁
  return true
}

总结

RWMutex 使用起来比较简单,相比 Mutex 而言,它区分了读锁和写锁,可以提高并发性能。最后,总结一下本文内容:

  • RWMutex 有两种锁:读锁和写锁。
  • 读锁可以被多个 goroutine 同时持有,写锁只能被一个 goroutine 持有。也就是可以并发读,但只能互斥写。
  • 写锁被占用的时候,其他的读和写操作都会被阻塞。读锁被占用的时候,其他的写操作会被阻塞,但是读操作不会被阻塞。除非读操作发生在一个新的写操作之后。
  • RWMutex包含以下几个方法:
  • Lock:获取写锁,如果有其他的写锁或者读锁被占用,那么就会阻塞等待。
  • Unlock:释放写锁。
  • RLock:获取读锁,如果写锁被占用,那么就会阻塞等待。
  • RUnlock:释放读锁。
  • 也包含了两个非阻塞的方法:
  • TryLock:尝试获取写锁,如果获取不到就返回 false,获取到了就返回 true。
  • TryRLock:尝试获取读锁,如果获取不到就返回 false,获取到了就返回 true。
  • RWMutex使用的注意事项跟Mutex差不多:
  • 使用之后不能复制
  • Unlock 之前需要有 Lock 调用,否则 panic,RUnlock 之前需要有 RLock 调用,否则 panic。
  • 不要忘记使用 Unlock 和 RUnlock 释放锁。
  • RWMutex的实现:
  • 写锁还是使用 Mutex 来实现。
  • 获取读锁和写锁的时候,如果获取不到都会阻塞等待,直到被唤醒。
  • 获取写锁的时候,会将 readerCount 减去 rwmutexMaxReaders,这样就可以直到有写锁被占用。释放写锁的时候,会将 readerCount 加上 rwmutexMaxReaders。
  • 获取写锁的时候,如果还有读操作未完成,那么这一次获取写锁只会等待这部分未完成的读操作完成。所有后续的操作只能等待这一次写锁释放。


目录
相关文章
|
缓存 安全 Java
Go RWMutex:高并发读多写少场景下的性能优化利器
RWMutex 是 Go 中的一种读写锁实现,它通过读锁允许多个 goroutine 同时执行读操作,当有写操作请求时,必须等待所有读操作执行结束后才能执行写操作。 RWMutex 的设计采用了 Write-preferring 方案,即如果有写操作在等待执行,新来的读操作将会被阻塞,以避免写操作的饥饿问题。 根据 RWMutex 的特性,它适用于 读多写少的高并发场景,可以实现并发安全的读操作,从而减少在锁竞争中的等待时间。 虽然它能够给程序带来了性能的提升,然而,如果使用不当,就可能会导致 panic 或死锁等问题。因此,在使用 RWMutex 时需要特别小心,并避免错误的用法。
20586 0
Go RWMutex:高并发读多写少场景下的性能优化利器
golang 系列:RWMutex 读写锁分析
在上一篇文章 [golang 重要知识:mutex](https://blog.csdn.net/h_l_f/article/details/118462433) 里我们介绍了互斥锁 mutex 的相关原理实现。而且在 Go 里除了互斥锁外,还有读写锁 RWMutex,它主要用来实现读共享,写独占的功能。今天我们也顺便分析下读写锁,加深对 Go 锁的理解。
700 0
golang 系列:RWMutex 读写锁分析
|
编译器 Go
揭秘 Go 语言中空结构体的强大用法
Go 语言中的空结构体 `struct{}` 不包含任何字段,不占用内存空间。它在实际编程中有多种典型用法:1) 结合 map 实现集合(set)类型;2) 与 channel 搭配用于信号通知;3) 申请超大容量的 Slice 和 Array 以节省内存;4) 作为接口实现时明确表示不关注值。此外,需要注意的是,空结构体作为字段时可能会因内存对齐原因占用额外空间。建议将空结构体放在外层结构体的第一个字段以优化内存使用。
|
运维 监控 算法
监控局域网其他电脑:Go 语言迪杰斯特拉算法的高效应用
在信息化时代,监控局域网成为网络管理与安全防护的关键需求。本文探讨了迪杰斯特拉(Dijkstra)算法在监控局域网中的应用,通过计算最短路径优化数据传输和故障检测。文中提供了使用Go语言实现的代码例程,展示了如何高效地进行网络监控,确保局域网的稳定运行和数据安全。迪杰斯特拉算法能减少传输延迟和带宽消耗,及时发现并处理网络故障,适用于复杂网络环境下的管理和维护。
|
存储 安全 Java
【Golang】(4)Go里面的指针如何?函数与方法怎么不一样?带你了解Go不同于其他高级语言的语法
结构体可以存储一组不同类型的数据,是一种符合类型。Go抛弃了类与继承,同时也抛弃了构造方法,刻意弱化了面向对象的功能,Go并非是一个传统OOP的语言,但是Go依旧有着OOP的影子,通过结构体和方法也可以模拟出一个类。
624 2
|
Cloud Native 安全 Java
Go:为云原生而生的高效语言
Go:为云原生而生的高效语言
915 1
|
开发框架 JSON 中间件
Go语言Web开发框架实践:路由、中间件、参数校验
Gin框架以其极简风格、强大路由管理、灵活中间件机制及参数绑定校验系统著称。本文详解其核心功能:1) 路由管理,支持分组与路径参数;2) 中间件机制,实现全局与局部控制;3) 参数绑定,涵盖多种来源;4) 结构体绑定与字段校验,确保数据合法性;5) 自定义校验器扩展功能;6) 统一错误处理提升用户体验。Gin以清晰模块化、流程可控及自动化校验等优势,成为开发者的优选工具。
|
JSON 编解码 API
Go语言网络编程:使用 net/http 构建 RESTful API
本章介绍如何使用 Go 语言的 `net/http` 标准库构建 RESTful API。内容涵盖 RESTful API 的基本概念及规范,包括 GET、POST、PUT 和 DELETE 方法的实现。通过定义用户数据结构和模拟数据库,逐步实现获取用户列表、创建用户、更新用户、删除用户的 HTTP 路由处理函数。同时提供辅助函数用于路径参数解析,并展示如何设置路由器启动服务。最后通过 curl 或 Postman 测试接口功能。章节总结了路由分发、JSON 编解码、方法区分、并发安全管理和路径参数解析等关键点,为更复杂需求推荐第三方框架如 Gin、Echo 和 Chi。
|
开发框架 JSON 中间件
Go语言Web开发框架实践:使用 Gin 快速构建 Web 服务
Gin 是一个高效、轻量级的 Go 语言 Web 框架,支持中间件机制,非常适合开发 RESTful API。本文从安装到进阶技巧全面解析 Gin 的使用:快速入门示例(Hello Gin)、定义 RESTful 用户服务(增删改查接口实现),以及推荐实践如参数校验、中间件和路由分组等。通过对比标准库 `net/http`,Gin 提供更简洁灵活的开发体验。此外,还推荐了 GORM、Viper、Zap 等配合使用的工具库,助力高效开发。
|
分布式计算 Go C++
初探Go语言RPC编程手法
总的来说,Go语言的RPC编程是一种强大的工具,让分布式计算变得简单如同本地计算。如果你还没有试过,不妨挑战一下这个新的编程领域,你可能会发现新的世界。
404 10

热门文章

最新文章