Mutex、RWMutex、atomic 到底该用哪个

Mutex、RWMutex、atomic 到底该用哪个
隔壁老康难度 ★★★★☆ · 前置:type switch 的 case 顺序决定走哪条路 | 一句话结论:这三种锁解决的不是同一个问题,atomic 管一个机器字,Mutex 管一段临界区,RWMutex 只在读远多于写时才划算,选错的代价是一个量级。
凌晨两点多,配置服务的 P99 忽然往上顶,QPS 掉了一半,可 CPU 各核都在三成上下晃,GC 没动静,火焰图上摸不到热点,pprof 里唯一在往上长的是 Mutex 的等待时间分布。那是个读多写少的配置缓存,加锁的地方统共三处,我挨个看过,都不长,也没一处里面做 IO。
后来才想明白,问题不在哪一段长,在用的东西不对。同一段逻辑把普通互斥锁换成读写锁,其余一个字都没动,读的那条路径快了一倍。下面这几组数是我这台机器上跑出来的,i9-14900HX,GOMAXPROCS 是 32,绝对值和你的机器肯定不一样,但排序和倍数关系基本能照搬。先看数。
三种锁,先看数
8 个 goroutine 各做 10 万次读,普通 Mutex 用了 26.356 毫秒,RWMutex 用了 12.4205 毫秒,差不多快了一倍。换成 atomic 的 Load,基准测试报出来是 5.888 纳秒一次,同一台机器上 Mutex 的读要 63.87 纳秒,RWMutex 是 33.11 纳秒。三个数放在一起,atomic 比 Mutex 快了十倍还多,这个差距跟实现写得好不好关系不大,它们在硬件层面做的事情压根不是一回事。
1 | BenchmarkAtomicRead8-32 200000 5.888 ns/op |
它保不住一段区间,中间那几步别人照样能插进来。
那组纳秒是用 b.RunParallel 跑出来的,它把 b.N 次迭代均摊给 GOMAXPROCS 个 goroutine,所以每个数背后都是真并发,不是一个线程跑完再换下一个。
这一点很重要,因为单线程下量出来的加锁成本只有几十纳秒,看起来还挺便宜,一旦真有多个人同时挤同一把锁,缓存行在你和对方之间来回搬的开销就冒出来了。
atomic 快是因为它只发一条 CPU 指令,不带任何等待队列,不进内核,也不需要唤醒谁;Mutex 慢是因为它的快路径虽然也只是一条比较并交换,但一旦有人排队,就要挂起、要唤醒、要让出时间片,这些动作都在操作系统调度器那一层,成本是微秒级的。
跑这几个基准的时候我把 -count 调大了,第一轮的数字总比后面几轮高一点,机器刚起来,核还没热,频率也没爬到位。
所以现在固定先空跑一轮丢掉,只取后面几轮,取到就收手,不再来回折腾。(图个心里踏实。)
快慢差一个量级,不是优化出来的。这几个数我重跑过,排序没变。
所以选哪个不该看谁快,要看你要保护的东西有多大。一个计数器、一个开关、一个指针,atomic 完全够用,而且没有死锁的可能。一旦你要保护的是两个以上互相关联的字段,atomic 就不够了,因为它只能保证单个变量的读写是原子的,两次原子操作之间照样能被插进来。
Mutex 里只有两个字段
标准库里的 Mutex 只有两个字段,一个 int32 的 state,一个 uint32 的 sema。state 看着像布尔值,其实是一堆标志位拼起来的整数:
| 位 | 记的是什么 |
|---|---|
| 最低位 | 锁着没锁着 |
| 第二位 | 有没有人已经被唤醒 |
| 第三位 | 是不是饥饿模式 |
| 其余高位 | 排队等锁的 goroutine 数量 |
sema 是给运行时用的信号量,真正负责挂起和唤醒。我第一次知道这件事的时候有点意外,因为我一直以为锁里面会有个队列,实际上队列不在锁里,在运行时的调度器那边。(重启之后一切照旧,像没发生过。)
这个结构最省的地方在于它没有一个字节是可选的。你想想一把锁需要记录多少东西,有没有人持有、有几人在等、等待的人里有没有已经被唤醒的、当前是不是饥饿状态,四个信息全塞进一个 int32,剩下的位数刚好够记到两百多万个等待者。这种做法在别的地方很少见,一般是建一个结构体然后逐字段读写,这里不行,因为要保证这四件事在一条指令里一起改,分开写就必然出现两个 goroutine 同时看到半新半旧状态的窗口。锁自己只记一个数。因为只有一个整数,加锁的快路径就是一条比较并交换,把零换成锁定位,成功就拿走。失败才走慢路径,慢路径里先自旋几次,赌持有者马上就要放,自旋还拿不到就把自己挂到 sema 上。自旋那几步也有讲究,它只在多核机器上做,只在临界区看起来很短的时候做,而且最多转四次,转完还不成就把自己记进等待者计数然后交给运行时挂起。这套设计的好处是没竞争的时候成本极低,代价是全部复杂逻辑都压在那条很少走到的慢路径里。我在 pprof 里见过一次长尾,问题最后定位到一个 goroutine 一边持锁一边做网络请求,持有时间几十毫秒,后面二十几个全在转完了排着,那段时间看起来就像整个服务变慢。(我自己把这段跑挂过一次,锁是在 defer 里放的,中间那个函数 panic 了,栈展开的时候 defer 还没来得及执行,十几个 goroutine 卡在 sema 上,最后只能 kill 进程。)
等过一毫秒,就换一种模式
flowchart TD
A["Lock()"] --> B["比较并交换,把零换成锁定位"]
B -->|"成了"| C["拿走,进临界区"]
B -->|"没成"| D["自旋几次,赌持有者马上放"]
D -->|"还是没拿到"| E["记进等待者计数,挂到 sema 上"]
E --> F{"等过 1ms"}
F -->|"没到"| E
F -->|"到了"| G["切饥饿模式,新来的直接排队"]
慢路径里有一行判据,等的时间超过 starvationThresholdNs 就切饥饿模式,这个常量在 D:/Go/src/internal/sync/mutex.go 第 55 行,值是 1e6,也就是一毫秒。我第一次找它翻错了文件,翻到同目录的 rwmutex.go 上去了,两个文件开头长得像,找了两分钟才发现名字不对。正常模式下,一个刚来的 goroutine 可以和排队最久的那位抢,抢赢了就直接拿走,这样吞吐高,但排队那位可能一直饿着。饥饿模式下锁的所有权直接从持有者手里交给队首,新来的不许抢,代价是吞吐掉一截。这个取舍很清楚,先保证没人被无限期拖死,再谈效率。翻到那一行,值就写在那儿。公平和吞吐,只能选一个。
这条判据平时不显眼,出事时才要命。
这个阈值不开放给你调,改不了。知道它存在的好处是,看到 pprof 里 Mutex 的等待时间分布时能猜出发生了什么。要是一个锁上出现大量一毫秒以上的等待,说明竞争已经很严重,正常模式压不住才切过去的,这时候该动的是临界区本身,而不是换锁。
RWMutex 只赢在读多
RWMutex 快一倍那个数有前提,是 8 个 goroutine 全在读。如果读写各占一半,读写锁的优势会迅速消失,因为它内部还要维护一个读者计数和一个写者信号,写的那一次得等所有读都退场。更麻烦的是它不保证公平,读者源源不断地进来,写者可能一直等下去。它内部那个读者计数是往上加的,写者占到锁里同一个位置就表示写锁被拿走了,所以读的人加一和写的人占位是同一个原子的两个方向,一条指令就能判出当前该不该放行。这种把读和写编码进同一个数的做法很巧,代价是加读锁也得走一次原子操作,比 atomic 的 Load 重不少,这也是为什么纯读的场景 atomic 一骑绝尘。我现在的判断标准很粗,读的比例超过九成才考虑 RWMutex,否则直接用 Mutex,省得为了那一倍的读性能多背一层复杂度。我在一个统计接口上试过,换过去之后读的那条线是平了,写的那几个请求反而慢了,一次写得等一整批读者退场,这种代价在平均值上看不出来。读锁和读锁之间,真的不互相等吗?
atomic 只能干一件小事
sync/atomic 在最近几个版本里加了带类型的包装,atomic.Int64 这类,用起来比传指针舒服,Load 和 Store 都不用再写取地址。但它能做的事始终只有一件,保证对一个机器字的读或者写是原子的,两次 Store 之间没有先后保证。所以拿它拼一个复合状态是有风险的,我见过有人用两个 atomic 分别存计数和状态,读的时候先读计数再读状态,结果读到一个不可能出现的中间组合。Go 的内存模型里,原子操作这一层给的是顺序一致,所有 goroutine 看到的原子操作顺序和程序里的顺序一致,不需要手工插屏障。这个保证比 C++ 里默认的宽松语义强,好处是写起来简单,代价是编译器在它周围不能做一些重排,极端场景下会稍微慢一点。日常业务根本感觉不到,我提这个是因为看到有人从别的语言迁过来,习惯性地想找一个 relaxed 版本,Go 里没有,不用找。内存模型这条线我另写过一篇,这里不摊开。两个 atomic 拼在一起那次,我又回头读输出。我在一个开关配置上踩过这个坑,版本号和生效时间分两个 atomic 存,先涨版本号再写时间,中间那一小段里读的人拿到新版本号配着老时间,算出来的过期判断是反的。这种错一天复现不了几次,抓到的时候日志两头都对得上,只有中间那一小段出过一次。(我一开始还以为是时钟漂移,查了两天才反应过来。)一个原子操作救不了两个字段,两次 CAS 之间还是一个空档,而那个空档正好是最贵的地方。
WaitGroup.Go 省掉三行
以前写 wg.Add(1) 加 defer wg.Done() 加一个匿名函数,是肌肉记忆,三行固定动作,漏掉 Add 程序直接 panic,漏掉 Done 永远卡住。现在 WaitGroup 有了 Go 方法,一行就能起一个任务,内部自己 Add 自己 Done。我实测跑了 8 个任务,cnt 最后是 8,量级上快到测不出来。省下来的其实是漏写 Add 那一类错误,这两个调用现在绑在一起,想漏也漏不出来,打字本身倒没省几个字。
老代码我一行一行全换过来了。少一个可以忘掉的地方。而错的那一类,本来也不该靠人来记。
替换的时候老代码和新的写法混在一个文件里,编译不报错,跑起来也对,只是同一个函数里两种风格并排放着,读起来别扭,我分了两次才拆干净。
同一个包里的 OnceValue 也值得说一句。它把只该执行一次的初始化包成函数,第一次调用时算,之后都返回缓存的那个值。我让 100 个 goroutine 一起去取,最终真实执行的次数是 1,返回值是 42。以前的写法是 Once 加一个包级变量,多两行,还多一个可能被改的地方。要是初始化会失败还要重试,另有一个 OnceValues 返回值和错误,语义更清楚一点。
sync.Map 的名字比适用面大
名字听起来像 map 的并发版本,实际不是。它的设计目标是那种写一次读很多次、或者多个 goroutine 各管各的键的场景,内部有两个 map,一个只读一个可写,读的时候尽量不碰锁。我实测 20000 次写入加 20000 次读取:
| 写法 | 耗时 | 相对倍数 |
|---|---|---|
sync.Map |
2.5026 ms | 2.5 |
map + sync.Mutex |
1.0031 ms | 1.0 |
sync.Map 反而慢了一倍半。这个数我一开始也不信,重跑几轮,结果稳定。原因在于它每次读都要先看只读的那张表,命中就返回,没命中或者需要提升的时候才加锁,而我的测试是把 20000 个键各写一次再各读一次,属于写多读少的形态,正好落在它最不擅长的区间里。同事说他那边跑出来是另一个数,他的机器是 M 系列,我们没有第二个环境可以对着跑,这事就一直放着没结论。不是所有场景都划算。原因很直接,这个量级下两个 map 之间的同步开销超过了锁本身,它优化的那种场景根本没出现。所以只有在你确实读多写少、键基本不变、而且不打算遍历的时候才考虑它。普通 map 加一把锁在绝大多数业务里够用,代码好懂,出问题也好查。后来我在一个连接表上又试了一次,那个表是启动时灌进去、之后只读、键的数量固定(这种形态下它确实比加锁的 map 合适),读的那条路径基本不碰锁。
同一份代码换个场景就是两张脸,我现在的做法是先看这张表有没有删除、有没有遍历,只要答案是经常,就不考虑它。
重复加锁会永远等下去
我第一次碰到不可重入是写一个递归函数,外层拿了锁,内层调用又拿一次,程序就停在那里不动,不报错,不 panic,CPU 也不高,就是不动。我写了个测试去确认这件事,主 goroutine 先拿锁,另开一个 goroutine 再拿,等 100 毫秒,那个 goroutine 没有返回。Go 的 Mutex 就是这样,它没有持有者的概念,不知道是哪个 goroutine 拿的,所以没法做重入判断。它不认人。
解决办法与其去找一把可重入的锁,不如把加锁的粒度改小,让内层函数不负责加锁,由外层统一管。这也是我后来更愿意用 TryLock 的原因之一,至少它不会卡在那里。TryLock 我测过,没被占的时候返回真,被占的时候立刻返回假,不阻塞。标准库文档里有一句提醒,说正确使用 TryLock 的场合很少,用它往往意味着别处有更深的问题。这话我信,所以我只在诊断和降级路径里用它。卡住的时候它连栈都不给你,只能看 goroutine 数往上爬。
复制一把锁,等于造了两把
go vet 有一条检查专门盯这个,把一个 Mutex 赋给另一个变量会直接报出来。我写了个最小例子,b := a 报 copybad.go:7:7: assignment copies lock value to b: sync.Mutex,连赋给下划线都报,报的是 assignment copies lock value to _: sync.Mutex。原因很简单,锁的状态全在那个整数里,复制一份就是两份独立的锁,两个 goroutine 各拿一把,谁也没挡住谁,而代码看上去还在加锁。这也是为什么 Mutex 里塞了个 noCopy 字段,它不占内存,纯粹是给编译器看的。拿结构体又试了一遍。所以我现在的习惯是结构体里带锁就一律用指针传,带锁的值接收者方法一个都不写。这条规矩救过我一次,一个配置结构体原本按值传,后来加了把锁保护热更新,如果还是按值传,那把锁就形同虚设,而所有代码看起来都还在加锁。
一张表收口
| 你要保护的 | 用哪个 | 理由 |
|---|---|---|
| 一个计数、一个开关 | atomic | 单个机器字够用,没有死锁 |
| 一段有多个字段的临界区 | Mutex | 通用,代价可控 |
| 几乎只读,偶尔整体替换 | RWMutex | 读的比例过九成才划算 |
| 写一次读很多次、键不变 | sync.Map | 场景对了才快 |
| 起一批任务等它们结束 | WaitGroup.Go | Add 和 Done 绑在一起 |
选错的代价不是慢一点,是慢一个量级,而且在压测曲线上看不出原因。












