2025 年 6 月 12 日 · JVM 与 Java 锁实践 06
一个内存配置表,99% 是读请求。看起来很适合读写锁,可替换以后吞吐没涨,写入延迟还更难预测。
读多只是一个比例。真正决定选型的,还有读操作有多短、读线程数量、写入突发、数据快照的构造成本,以及读到不一致状态后能不能安全重试。
这篇固定 JDK 21.0.5。先从 ReentrantReadWriteLock 的状态编码读起,再看 StampedLock 的版本校验,最后用实验确认升级、降级和非重入这些边界。
读锁共享,不代表每个读请求完全没有竞争 ReentrantReadWriteLock 把同步状态装进一个 int:高 16 位用于共享读计数,低 16 位用于独占写计数。读写计数的提取与上限检查,都能在源码里直接找到。状态定义
多个读者可以同时持有读锁,但它们仍可能竞争修改共享计数,以及执行重入记录和排队策略。读路径只有几次字段访问时,这些同步开销就可能占相当大的比例。
源码还用 firstReader、cachedHoldCounter 与线程持有计数等信息处理重入和释放。高位记录的总读计数,不能单独回答“当前线程持有几次读锁”。持有计数相关实现
因此,判断它是否适合,不能只把读请求数量除以总请求数量。锁内工作量、共享计数竞争以及写者能否及时推进,都要一起测。
tryAcquire 与 tryAcquireShared,决定能否进入 写锁获取先看当前 state。如果有其他持有者,或者只有非零读计数而没有当前线程的写持有关系,就不能按普通写获取成功。写线程重入则按独占计数处理。写获取路径
读获取既要排除其他线程持有写锁,也要结合 readerShouldBlock 等策略。非公平模式也不是“所有读者无限插队”,代码会考虑队列中的特定等待情况;公平模式的规则又不同。读获取路径
业务不能根据源码里的一个 if,就承诺写者永不饥饿。锁策略、调用方式与调度共同影响进度,读操作如果长期不释放,写者自然也无从进入。
降级有受保护的交接点,升级则可能把自己卡住 写锁降级的顺序是:仍持有写锁时先获取读锁,然后释放写锁。这样从修改状态走到后续受保护读取,中间没有给另一个写者插入的空档。
如果先释放写锁再拿读锁,那是两次独立获取,间隙中可能已有其他写入。是否允许这个空档,要看你是否仍依赖刚刚写好的状态。
反过来,持有读锁再直接获取写锁,并不是对称操作。即使当前看起来只有自己一个读者,这个实现的普通获取协议也不会自动把它升级成写锁;继续阻塞等待,还可能让自己等着自己释放读锁。
本次实验使用带超时的获取,避免把实验线程永久挂住:读锁未释放时尝试写锁,结果 false;写锁先拿读锁再释放写锁,竞争写者也返回 false;最后读锁释放,竞争写者才成功。
如果业务必须从检查走到修改,我会释放读锁、再获取写锁,并在写锁内重新检查条件。重新检查是必要步骤,两个获取之间状态可能已经变化。
StampedLock 的乐观读,没有拿住一把共享读锁 tryOptimisticRead 在没有独占写持有时返回一个可验证的 stamp,否则返回 0。stamp 与版本和锁状态有关,不是一个单纯的布尔值。乐观读入口
validate 的源码很短,关键包括读取排序与版本相关位比较:
1 2 U.loadFence(); return (stamp & SBITS) == (state & SBITS);
这是该版本的原始摘录 。我们应结合方法契约和 stamp 的生成理解它,不能只把它简化为“当前没有写锁就成功”。从获取 stamp 以来发生过一次写获取并释放,即便此刻已经没有写者,旧 stamp 也可能失效。
典型做法是先把安全读取的字段复制到局部变量,再 validate;失败后获取真正的读锁,重新读取整份快照。通过校验之前,不要用不稳定的中间状态去发请求、修改外部数据或遍历可能被并发破坏的可变对象图。
1 2 3 4 5 6 7 8 9 10 11 12 13 long stamp = lock.tryOptimisticRead();double localX = x;double localY = y;if (!lock.validate(stamp)) { stamp = lock.readLock(); try { localX = x; localY = y; } finally { lock.unlockRead(stamp); } } return new Point (localX, localY);
这里假设 x、y 的所有修改都遵守同一 StampedLock 的写协议,Point 是这次读产生的独立快照。其他路径绕过锁写字段,validate 不会替那条路径补上正确性。
如果读的是一个可能被清空的数组或复杂链表,连校验之前的遍历都可能不安全。这时先用不可变快照、真正的读锁或其他适合的数据结构,通常更容易把协议讲清楚。
条件转换与可重入,是两种独立能力 tryConvertToWriteLock 会按当前模式、stamp 和总状态尝试转换。源码中,读转写成功的一种关键情况是当前只有相应的一个读持有;读者不止一个时,转换可能失败并返回 0。转换实现
不要因为它“支持升级”,就假设任何时候都能原地升级成功。转换失败后,需要正确释放自己仍持有的读锁,按业务决定是否重新获取写锁,并重新检查原来的条件。
StampedLock 也不是可重入锁。自己持有写锁后再无条件 writeLock,可能把自己阻塞住。回调、嵌套服务调用、日志钩子如果偷偷重复获取同一锁,这个差异特别容易暴露。
它的 stamp 还承担解锁能力,不按 ReentrantLock 那样绑定一个独占 owner 线程来解释;跨线程交接这份能力时,要明确谁负责最终释放。它不提供与 ReentrantLock 相同的 Condition 等待模型,也不应被当作通用接口的透明替换。
这次实验验证了什么
检查
本次结果
降级后仍有读锁,另一写者能否进入
false
最后读锁释放后,另一写者能否进入
true
持读锁尝试升级 ReentrantReadWriteLock
超时,false
乐观读后发生写锁获取/释放,旧 stamp 是否有效
false
StampedLock 有两个读持有时转换
false
剩一个读持有时转换
true
持写锁再次限时获取 StampedLock 写锁
false
乐观读实验中的写者只完成一次写锁获取与释放,就让旧 stamp 失效。这证明校验关注的是相应写周期,不是在逐字段比较业务值是否真的改变。
1 python3 lab/run.py readwrite --jdk "$JVM_LAB_JDK "
源码为 ReadWriteLab.java ,完整输出为实验记录 。这些短程序用于验证协议,不用于证明哪个锁的生产吞吐更高。
真正选型时,我会把快照方案也放进来比较
需求
我会先考虑
需要验证的成本
简短、明确的独占修改
synchronized 或 ReentrantLock
竞争与持锁时间
读操作较长,可并行且写入较少
ReentrantReadWriteLock
读计数竞争、写者延迟
很短的字段快照,可安全校验重读
StampedLock 乐观读
校验失败率、回退成本与协议复杂度
配置整体替换、读取极短
不可变对象 + 安全发布引用
构造成本、旧快照回收与一致性范围
不可变快照方案也有前提:快照内部不能继续被其他线程修改,发布方式要满足可见性要求。它用写入时的构造与分配成本,换取简单的读取路径;对象较大或更新频繁时也要看 GC 压力。
最后我会在真实读写比例、突发写入和线程规模下比较吞吐、读 P99、写 P99、CPU 与分配率。一个读写锁如果让读快一点,却把关键写入一直拖后,这个结果未必符合业务目标。
本篇完整 Java 示例 下面代码与配套实验使用的源文件一致。编译参数、Agent 打包和 jcmd 采集由 lab/run.py 统一组织,入口见文末实验环境说明。
展开本篇完整 Java 示例
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.AtomicBoolean;import java.util.concurrent.locks.ReentrantReadWriteLock;import java.util.concurrent.locks.StampedLock;public class ReadWriteLab { static boolean competingWriterAcquires (ReentrantReadWriteLock lock) throws Exception { AtomicBoolean result = new AtomicBoolean (); Thread thread = new Thread (() -> { try { if (lock.writeLock().tryLock(80 ,TimeUnit.MILLISECONDS)) { try { result.set(true ); } finally { lock.writeLock().unlock(); } }} catch (InterruptedException error) { throw new RuntimeException (error); } }); thread.start(); thread.join(3000 ); if (thread.isAlive()) throw new AssertionError (); return result.get(); } public static void main (String[] args) throws Exception { ReentrantReadWriteLock rw = new ReentrantReadWriteLock (); rw.writeLock().lock(); rw.readLock().lock(); rw.writeLock().unlock(); boolean duringRead = competingWriterAcquires(rw); System.out.println("writer_acquires_during_downgraded_read=" + duringRead); rw.readLock().unlock(); boolean afterRead = competingWriterAcquires(rw); System.out.println("writer_acquires_after_read_unlock=" + afterRead); rw.readLock().lock(); boolean upgrade = rw.writeLock().tryLock(80 ,TimeUnit.MILLISECONDS); System.out.println("rw_read_to_write_upgrade=" + upgrade); if (upgrade) rw.writeLock().unlock(); rw.readLock().unlock(); StampedLock stamped = new StampedLock (); long optimistic = stamped.tryOptimisticRead(); int copied = 1 ; Thread writer = new Thread (() -> { long stamp = stamped.writeLock(); try {} finally { stamped.unlockWrite(stamp); } }); writer.start(); writer.join(); boolean valid = stamped.validate(optimistic); System.out.println("optimistic_copy_before_write=" + copied); System.out.println("validate_after_writer_unlock=" + valid); long first = stamped.readLock(), second=stamped.readLock(); long failed = stamped.tryConvertToWriteLock(first); System.out.println("conversion_with_two_readers=" + (failed!=0 )); stamped.unlockRead(second); long success = stamped.tryConvertToWriteLock(first); System.out.println("conversion_with_one_reader=" + (success!=0 )); if (success==0 ) { stamped.unlockRead(first); throw new AssertionError (); } long reentry = stamped.tryWriteLock(50 ,TimeUnit.MILLISECONDS); System.out.println("stamped_write_reentrant=" + (reentry!=0 )); if (reentry!=0 ) stamped.unlockWrite(reentry); stamped.unlockWrite(success); if (duringRead || !afterRead || upgrade || valid || failed!=0 || reentry!=0 ) throw new AssertionError (); } }
实验环境与运行脚本 准备完整的 Temurin 21.0.5+11 JDK ,选择与系统架构相符的包,并按同名 .sha256.txt 校验。需要包括 java、javac、jar、jcmd、jfr;这里固定版本是为了对应本文源码与实验结果。
将前面的 Java 示例保存为 lab/ReadWriteLab.java,把下面脚本保存为 lab/run.py。在自己的实验项目根目录执行:
1 2 3 4 export JVM_LAB_JDK=/你的路径/jdk-21.0.5+11"$JVM_LAB_JDK /bin/java" -versionpython3 lab/run.py readwrite --jdk "$JVM_LAB_JDK "
Python 脚本无第三方依赖,只编译本篇 Java 示例,输出到本项目的 assets/06-readwrite/。诊断采集仅针对脚本自己启动的实验 JVM;运行结束会退出该进程。
展开本篇独立运行脚本
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 from pathlib import Pathimport argparse,datetime,hashlib,json,os,platform,re,subprocess,timeROOT=Path(__file__).resolve().parents[1 ] def execute (args,timeout=25 ): result=subprocess.run([str (x) for x in args],text=True ,capture_output=True ,timeout=timeout) if result.returncode:raise RuntimeError(result.stderr[-2500 :]+result.stdout[-2000 :]) return result.stdout+result.stderr def pairs (text ): return dict (line.split('=' ,1 ) for line in text.splitlines() if re.match (r'^[A-Za-z0-9_]+=' ,line)) def main (): parser=argparse.ArgumentParser() parser.add_argument('experiment' ,choices=['readwrite' ,'all' ]) parser.add_argument('--jdk' ,required=True ) args=parser.parse_args() name='readwrite' jdk=Path(args.jdk).resolve();java=jdk/'bin/java' ;javac=jdk/'bin/javac' ;jar=jdk/'bin/jar' ;jcmd=jdk/'bin/jcmd' version=execute([java,'-version' ]) assert '21.0.5' in version and '21.0.5+11' in version build=ROOT/'lab/build' ;build.mkdir(parents=True ,exist_ok=True ) execute([javac,'-d' ,build,ROOT/'lab/ReadWriteLab.java' ]) dest=ROOT/'assets/06-readwrite' ;dest.mkdir(parents=True ,exist_ok=True );logs=[] def run (*flags,timeout=25 ): command=[java,*flags];out=execute(command,timeout);logs.append('$ ' +' ' .join(str (x) for x in command)+'\n' +out);return out result = pairs(run('-cp' , build, 'ReadWriteLab' )) assert result['conversion_with_two_readers' ] == 'false' and result['conversion_with_one_reader' ] == 'true' and (result['validate_after_writer_unlock' ] == 'false' ) record={'experiment' :name,'runtime' :version.strip(),'os' :platform.platform(),'executed_at' :datetime.datetime.now(datetime.timezone.utc).isoformat(),'result' :result} (dest/'result.json' ).write_text(json.dumps(record,ensure_ascii=False ,indent=2 )) (dest/'execution.txt' ).write_text('\n\n' .join(logs)) print (json.dumps({'experiment' :name,'result' :result},ensure_ascii=False )) if __name__=='__main__' :main()
实验记录 下面是本文配图采用的结果摘要;再次运行得到的计数、采样和日志时间会受环境影响。脚本会同时生成完整日志,诊断篇还会生成 JFR 文件。
展开本篇实验结果
1 2 3 4 5 6 7 8 9 10 { "writer_acquires_during_downgraded_read" : "false" , "writer_acquires_after_read_unlock" : "true" , "rw_read_to_write_upgrade" : "false" , "optimistic_copy_before_write" : "1" , "validate_after_writer_unlock" : "false" , "conversion_with_two_readers" : "false" , "conversion_with_one_reader" : "true" , "stamped_write_reentrant" : "false" }
固定源码入口
源码版本一致以后,图上的每个箭头才有明确含义:哪一步改变状态,哪一步只是尝试,失败以后手里还持有什么,以及重新读取时要再检查什么。