2025 年 6 月 12 日 · JVM 与 Java 锁实践 06

一个内存配置表,99% 是读请求。看起来很适合读写锁,可替换以后吞吐没涨,写入延迟还更难预测。

读多只是一个比例。真正决定选型的,还有读操作有多短、读线程数量、写入突发、数据快照的构造成本,以及读到不一致状态后能不能安全重试。

这篇固定 JDK 21.0.5。先从 ReentrantReadWriteLock 的状态编码读起,再看 StampedLock 的版本校验,最后用实验确认升级、降级和非重入这些边界。

读锁共享,不代表每个读请求完全没有竞争

ReentrantReadWriteLock 把同步状态装进一个 int:高 16 位用于共享读计数,低 16 位用于独占写计数。读写计数的提取与上限检查,都能在源码里直接找到。状态定义

读计数和写计数怎样放进同一份 state

多个读者可以同时持有读锁,但它们仍可能竞争修改共享计数,以及执行重入记录和排队策略。读路径只有几次字段访问时,这些同步开销就可能占相当大的比例。

源码还用 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,完整输出为实验记录。这些短程序用于验证协议,不用于证明哪个锁的生产吞吐更高。

读写锁与 StampedLock 的真实边界实验

真正选型时,我会把快照方案也放进来比较

需求 我会先考虑 需要验证的成本
简短、明确的独占修改 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
# macOS JDK 包通常需追加 /Contents/Home。
"$JVM_LAB_JDK/bin/java" -version
python3 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 Path
import argparse,datetime,hashlib,json,os,platform,re,subprocess,time

ROOT=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"
}

固定源码入口

源码版本一致以后,图上的每个箭头才有明确含义:哪一步改变状态,哪一步只是尝试,失败以后手里还持有什么,以及重新读取时要再检查什么。