第 9 篇已经把「线程、channel、Arc<Mutex<T>>」这条主线走通了。实际项目里还会遇到两个更具体的问题:一是读多写少的场景,所有读操作都被同一把 Mutex 串行化,吞吐上不去;二是 Arc 的强引用计数只涨不降,内存就是释放不掉,日志里却看不出谁在持有。

这两个问题都不是「换个函数」能解决的。第一个要求你理解读写锁的语义和它的代价;第二个要求你理解 Arc 到底在数什么、Send/Sync 到底在约束谁。这一篇把共享状态往深处推一层:RwLock、原子操作、锁的粒度、死锁与中毒。示例都在本机实际跑过。

RwLock:多读单写,但不是免费的

RwLock<T> 的规则是「同一时刻,要么多个读者,要么一个写者」。读操作拿 read(),写操作拿 write(),两者都返回 guard,guard 离开作用域即释放。它适合「读远多于写」的缓存、配置表、索引。

实测三个线程同时持有读锁,主线程尝试 try_write:

write     => failed: try_lock failed because the operation would block
reader    => sees 0
reader    => sees 0
reader    => sees 0
write     => after readers: 7

这组输出说明两件事:多个读可以同时持有,写会被挡住;写锁要等所有读锁释放才能拿到。注意顺序,三个读者是在主线程尝试写之后才打印的,因为主线程在等它们释放。

关键取舍在于:RwLock 不是「比 Mutex 快」的同义词。它的内部要维护读者计数和写者状态,读锁的获取通常比 Mutex 更贵;只有读操作占多数、且读操作有一定耗时时,收益才明显。如果临界区只有一两个原子操作,RwLock 的额外开销可能让整体更慢。选它之前先问:读和写的比例是多少?临界区有多长?

另一个要命的点是「写者饥饿」。不同平台的实现策略不同,有的偏向读者,持续不断的读会让写者一直等不到;标准库不承诺公平性。如果你的业务里写入必须及时生效,要么控制读锁的持有时间,要么用「读写分离 + 定期切换」的设计,别指望锁本身给你公平。

还有一个使用上的坑:拿着读锁不能直接升级成写锁。想在「读到不存在就写入」的场景里先 read() 再 write(),必须先把读 guard drop 掉,否则同一线程会等自己释放,直接死锁。这类「检查再更新」的逻辑更适合用 write() 一次拿到写锁,或者用 Mutex 加普通判断,别在 RwLock 上做锁升级的梦。

RwLock 也会中毒:写者在持锁期间 panic,后来的读写都会拿到 Err。读锁中毒的判定比 Mutex 更微妙,因为可能有多个读者同时持锁,谁触发的中毒要靠调用方自己判断。实际项目里,如果数据可以重建,直接丢弃并重建往往比「修复中毒状态」更安全。

Mutex:锁的作用域就是 guard 的生命周期

Mutex 只有一把钥匙。它简单、可预测,适合写多或临界区很短的场景。最容易出问题的地方不是 lock 本身,而是「锁被持有多久」。

guard 是一个值,它的生命周期决定锁何时释放。写在一条语句里的临时 guard,会在语句结束时释放;绑定到变量上的 guard,会活到变量离开作用域。很多人以为「函数返回才释放」,结果在锁里做了网络请求、文件读写、日志落盘,整个程序的并发度被这一把锁压成串行。

实测用 try_lock 观察「锁被占用」的即时返回:

try_lock  => failed: try_lock failed because the operation would block

try_lock 不等待,拿不到立刻返回 Err。它适合「拿不到就走另一条路」的场景,比如缓存未命中时去查数据库,而不是傻等。用它做「避免死锁」的工具也有局限:两个线程都用 try_lock 并且都失败后重试,可能形成活锁,一直在互相礼让。

锁中毒(poisoning)是 Rust 的特有设计:持有锁的线程 panic 后,锁会被标记为中毒,后来者 lock() 拿到 Err。实测:

poison    => poisoned, recover len=4

中毒不是「锁坏了」,而是「上一次持锁的人死在了临界区,数据可能只改了一半」。into_inner() 能强行取出数据继续用,但你要自己判断这份数据还合法吗。很多服务选择「中毒即重启」,因为状态已经不可信;库代码则应该把「数据可能不一致」这件事暴露给调用方,而不是默默清空。

有些同步问题一把锁表达不了,比如「等队列里有数据再取」。这时要用 Condvar(条件变量):它和一个 Mutex 搭配,让线程在条件不满足时释放锁并睡眠,条件满足时被唤醒。坑在于「虚假唤醒」——等待可能没有收到通知就返回,所以判断条件必须写在循环里,醒来后重新检查。用 Condvar 手写生产者消费者当然可以,但大多数场景直接用 std::sync::mpsc 通道更省心:通道本身就是「有界队列 + 阻塞等待」的组合,语义比手写锁更清楚。

不要在持锁期间做可能 panic 的操作,尤其是 unwrap、数组下标、除法。一次 panic 会让整把锁进入中毒状态,影响所有后来者。能在锁外做的校验就放到锁外,必须做的就用 match 处理错误。

Send 与 Sync:约束的是「能不能跨线程」

这两个 trait 没有任何方法,它们是标记:Send 表示「这个值的所有权可以转移到另一个线程」,Sync 表示「&T 可以同时被多个线程持有」。T: Sync 等价于 &T: Send。

组合出来的规则要记清:Arc<T> 能跨线程共享,要求 T: Send + Sync;Mutex<T> 自己是 Sync 的前提是 T: Send,因为它保证同一时刻只有一个线程访问内部值;Rc<T> 和 RefCell<T> 不是 Sync,因为它们的引用计数和借用标志不是原子操作,多线程同时改会直接坏掉。

编译器报错通常长这样:`Rc<Vec<i32>>` cannot be sent between threads safely,后面跟一句 within `...`, the trait `Send` is not implemented for `Rc<...>`。读这种报错不要只看第一行,往下找「哪个类型没有实现哪个 trait」,再回到结构体定义看它为什么没有。多数情况是里面藏了一个 Rc、RefCell 或裸指针。

还有一个常见误区:以为实现了 Send 就线程安全。Send 只保证「转移所有权」不违反内存安全,不保证业务逻辑正确。两个线程各自持有一个 Send 的值,仍然可能通过文件、数据库、全局变量互相踩。Rust 的类型系统挡的是数据竞争,不是所有并发错误。

原子操作:无锁不等于更快

原子类型(AtomicUsize、AtomicBool 等)提供不可分割的读改写。最常用的是 fetch_add 做计数、compare_exchange 做「只有没人改过才更新」。实测八个线程各累加十万次:

atomic    => 800000

结果正确,没有丢更新。再用 compare_exchange 抢一个「只初始化一次」的开关:

cas       => thread 7 won
cas       => final 8

哪个线程赢是调度决定的,每次运行都可能不同;这里能确定的只有「恰好一个赢,最终值等于赢家写入的值」。如果你的测试断言了具体线程编号,它迟早会随机失败。

原子操作的难点是内存顺序。Relaxed 只保证这个操作本身不可分割,不保证它和其他读写之间的先后关系;Acquire/Release 用来建立「一个线程发布、另一个线程看到」的同步;SeqCst 是最强的全局顺序,也最贵。写计数器用 Relaxed 通常够;用原子变量传递「初始化完成」这类信号,必须用 Acquire/Release 或 SeqCst,否则另一个线程可能看到「标志已置位」但看不到标志之前写入的数据。

无锁方案的代价远不止一条指令的复杂度。单个计数器可以用原子变量,但一旦要维护链表、队列、哈希表,就得面对 ABA 问题、内存回收(一个线程刚读完节点,另一个线程把它释放了)、以及不同 CPU 架构的内存模型差异。成熟的无锁结构通常需要 epoch 回收、hazard pointer 这类机制,代码量和调试难度都远超一把锁。结论很朴素:能用锁解决就先上锁,只有压测证明锁是瓶颈、且业务能承受复杂度时,才考虑无锁。

锁的代价:争用、粒度和锁内 IO

锁的成本分三段:无争用时是一次原子操作,几十纳秒量级;有争用时线程要进入内核等待、被唤醒,涉及上下文切换;争用严重时还会出现「刚唤醒又被抢走」的抖动。真正的吞吐下降往往不是锁本身,而是锁把并行变成了串行。

粒度是个权衡。锁得太粗,所有操作排队;锁得太细,每次操作要拿多把锁,死锁风险和开销都上升。常见做法是按数据分片:把一个大 HashMap 拆成 N 个分片,每个分片一把锁,按 key 的哈希选分片。这样不同 key 的操作可以并行,代价是遍历、扩容、统计变复杂。分片数不是越多越好,超过 CPU 核数意义不大。

最该避免的是「锁内做慢操作」:网络请求、磁盘 IO、日志落盘、sleep,任何一个都会把锁的持有时间从微秒拉到毫秒甚至秒。正确做法是在锁内只做内存状态的读取和修改,把值 clone 出来,释放锁之后再做事。代价是要处理「读到的值可能已经过期」,这属于业务一致性设计,不是锁能解决的。

还有一个容易忽略的细节:std::sync::Mutex 不是为异步设计的。它的 guard 不能跨 await 持有,因为 guard 往往不是 Send,编译器会直接拦下来。这不是坏事:跨 await 持锁会把整个执行器卡住。异步场景要用 tokio::sync::Mutex,或者更好的做法是根本不在 await 期间持锁。

锁和通道是两种不同的问题模型。锁解决「多个线程改同一份数据」,通道解决「多个线程传递数据」。如果线程之间只需要把结果交给别人,用通道比用共享状态更简单:没有锁顺序、没有死锁、没有中毒,消费方处理完自然释放。很多「锁导致卡死」的设计,本来可以用一条通道替代。先问「这块数据真的需要被多方同时改吗」,再决定用哪种工具。

死锁与 Arc 计数:两个靠日志才能查的坑

死锁的经典形态是「两个线程、两把锁、相反顺序」:线程 A 先拿 X 再等 Y,线程 B 先拿 Y 再等 X。单看每个线程都没问题,合起来永远解不开。避免方式不是「小心一点」,而是定一条全局规则:所有代码按固定顺序获取多把锁,或者一次只持有一把。更复杂的情况用 try_lock 加超时,拿不到就释放已持有的锁再重试,但要注意活锁。

Arc 计数不降的原因通常有三个。第一,某个 clone 被存进了全局注册表、缓存、线程闭包,没人移除。第二,结构体之间形成了循环引用:A 持 B 的 Arc,B 又持 A 的 Arc,计数永远至少是 2。第三,把 Arc 传进了长期运行的线程或后台任务,任务不结束,引用就不释放。排查工具是 Arc::strong_count(&value) 和 weak_count,在关键路径打印计数变化,能很快定位是哪一步多出来的。循环引用要用 Weak 打破其中一条边。

Arc 的计数是原子的,但「计数正确」不等于「对象一定安全」。Arc 管理的是生命周期,不管理内部可变性;要修改内部值仍然需要 Mutex、RwLock 或原子类型。把 Arc 当成「线程安全的万能容器」是常见误解。

现象对照

现象真实原因第一步查什么
读多写少的服务吞吐上不去所有读都被同一把 Mutex 串行化看读/写比例,读远多于写时评估 RwLock
换成 RwLock 反而更慢临界区太短,读写锁自身开销超过收益测临界区长度,短临界区用 Mutex 或原子操作
写入迟迟不生效,读请求一直不断读锁持续占用,写者饥饿,标准库不保证公平缩短读锁持有时间,限制并发读者,或换设计
lock() 返回 Err(PoisonError)上一个持锁线程 panic,数据可能只改了一半决定重启还是用 into_inner() 校验后继续
Rc<T> is not SendRc 的计数不是原子操作,不能跨线程换 Arc;要改内部值再加 Mutex
程序跑一段时间后完全卡住两个线程以相反顺序获取两把锁用线程 dump 看各线程等哪把锁,统一锁顺序
Arc::strong_count 一直上涨clone 被缓存/全局表/循环引用持有在 clone 与 drop 处打点,循环引用改 Weak
持锁后接口响应变成秒级锁内做了网络/磁盘 IO 或 sleep把 IO 移到锁外,锁内只改内存状态
异步任务里编译报 guard 不是 Send跨 await 持有 std::sync 的锁缩短 guard 作用域,或改用异步专用锁

边界与代价

第一层是「锁只保护它保护的东西」。Mutex<T> 保护的是 T,不是「整个业务状态」。两个不同的 Mutex 之间没有一致性保证;跨进程的共享状态更不在它的能力范围内。设计时先画清楚「哪些数据必须一起改」,再决定用一把锁还是多把。

第二层是可移植性。RwLock 的公平性、原子操作的内存序实现、锁的底层系统调用,各平台都不一样。代码在不同平台上都正确,不代表性能表现一样。需要跨平台调优时,必须分别压测,不能拿一个平台的结论套另一个。

第三层是调试成本。死锁、活锁、饥饿、计数泄漏,往往在压力下才出现,单机跑几分钟测不出来。可观测性要提前做:给关键锁记录等待时间,给 Arc 计数做快照,给线程起名字。Rust 的类型系统挡不住这些问题,只能靠工程手段。

第四层是「无锁」的诱惑。无锁听起来高级,实际要求对内存模型、CPU 架构、对象生命周期都有把握。绝大多数业务用锁就够了,把锁的粒度调好、把锁内 IO 移走,收益远大于硬写一个无锁队列。把复杂度花在真正瓶颈上,而不是花在「看起来更牛」的实现上。

小结

把这一篇收成四句:读多写少可以上 RwLock,但短临界区和写多场景用 Mutex 或原子操作更合适;Send/Sync 约束的是跨线程转移与共享,不保证业务正确;原子操作解决单个值的不可分割,解决不了复杂结构的生命周期;Arc 计数不降先查 clone 被谁持有,再查循环引用。

线程之间共享内存有锁可用,进程之间没有。下一个问题更硬:两个进程怎么看到同一块内存?答案是 mmap 或共享内存对象;如果只是想传消息,Unix socket 更简单。下一篇讲这两条路,以及在 Windows 上怎么用命名共享内存把计数器从父进程交给子进程。

当天可以自己验证的练习:

  1. 把第 9 篇的 Arc<Mutex<Vec>> 改成 Arc<RwLock<Vec>>,开 8 个读线程和 1 个写线程,观察读写比例变化时的总耗时。
  2. 写一个「持锁线程 panic」的例子,分别用 lock().unwrap() 和 into_inner() 处理,确认两次行为差异。
  3. 用 compare_exchange 实现一个自旋锁,跑两个线程各加十万次,确认最终计数正确。
  4. 故意写一个两把锁相反顺序的程序,跑起来观察卡死,再用固定顺序修好。
  5. 写一个循环引用:A 持 Arc<B>、B 持 Arc<A>,打印 strong_count,再把其中一条边改成 Weak 对比。

这五条跑完,锁与引用计数这一层基本就有手感了。真遇到线上卡死或内存不释放,也知道从哪几个点开始查。