一、起源:性能优化前的判断问题

1.1 改动是否真的更快

性能优化中的大部分决策都可以归结为一个比较问题:把实现 A 换成实现 B,是否真的更快,快多少。这类决策的输入通常来自三处。

来源 能给出的结论 局限
复杂度分析 增长量级(O(n) 与 O(n²) 的差别) 相同量级下无法比较;常数因子可能相差数倍
经验判断 常见实现的大致排序 与数据规模、JDK 版本、库实现相关,结论会失效
实测 特定条件下的数值 需要一套可复现的测量方法,否则数值本身不可信

实测的困难在于被测对象的量级。方法级的一次调用常见在纳秒到微秒之间,与计时器分辨率、即时编译状态、CPU 缓存状态处于同一数量级,测量动作本身就会改变被测量对象的执行形态。缺少方法时,得到的数值看似精确,实际反映的是测量环境的偶然状态。

1.2 手写计时代码的失效原因

最直接的做法是在代码中插入计时语句。

public class NaiveTimer {

    public static void main(String[] args) {
        long checksum = 0;
        for (int round = 0; round < 10; round++) {
            long start = System.nanoTime();
            checksum += compute();
            long cost = System.nanoTime() - start;
            System.out.println("第 " + round + " 轮耗时(ns): " + cost);
        }
        System.out.println("校验值: " + checksum);
    }

    static int compute() {
        int sum = 0;
        for (int i = 0; i < 1000; i++) {
            sum += i;
        }
        return sum;
    }
}

这段代码可以运行,输出也符合直觉,但结论不可用。失效来自四个方面。

预热不足。 前几轮由解释器逐条翻译字节码执行,方法被调用足够多次后触发即时编译(Just-In-Time,以下简称 JIT),耗时随之出现数量级的下降。实际输出通常呈现"前两轮很慢、后续轮次变快并趋于平稳"的形态:取第一轮的值得到的是解释执行的耗时,取最后一轮的值也未必落在稳定区间。

死代码消除与常量折叠。 compute 没有副作用,循环的累加结果是一个可在编译期推导的常量。JIT 内联 compute 之后,可以判定整个 1000 次循环的结果固定,进而把计算折叠为常量甚至整体消除。此时测得的耗时接近零,而这个零并不代表"这段计算很快"。若 checksum 也不被使用,main 内的循环同样可能被整体优化掉。

测量动作本身的开销。 System.nanoTime 的调用需要经过系统调用路径,在部分平台上开销可达数十纳秒,与被测方法的耗时相当。计时语句的插入位置、JIT 是否内联计时调用,都会改变结果。

外部干扰。 单次测量的时间窗口很短,期间发生一次年轻代垃圾回收、一次线程调度、一次 CPU 频率切换,都足以使该轮数值偏移一个数量级,而这些事件的出现与否不受代码控制。

失效模式 成因 表现
结果逐步变好 解释执行切换到 JIT 编译 前几轮与后几轮相差数倍,结论取决于取哪一轮
耗时接近零 死代码消除、常量折叠 改动看起来"优化到了极致",实际是被优化掉了
数值波动极大 GC、线程调度、CPU 调频 同一份代码重复运行得到不同结论
差异无法归因 多种干扰叠加 无法判断差异来自被测代码还是环境

这些失效模式无法靠"多跑几次取平均"解决:平均值会把真实差异与干扰一起平均,且无法区分两者各占多少。

1.3 微基准与系统压测的分工

微基准测试(microbenchmark)是在单个 JVM 进程内、针对方法或少量代码路径的测量,回答"同一功能的两种实现,在相同输入下哪一个的局部成本更低"。

方法 观测对象 回答的问题 结论的作用范围
微基准 JVM 内的方法或代码路径 哪种实现更快,差异量级是多少 该实现、该 JDK 版本、该输入规模下的相对成本
系统压测 完整服务与主机资源 能承载多少并发,延迟分位是多少 该环境与配置下的容量边界,方法见 linux: 压测与性能基线
线上观测 真实流量下的实际表现 变更后真实用户体验是否改善 当前版本在当前数据分布下的实际结果

三者的关系是分工而不是替代:微基准用于在若干候选实现之间筛选,成本低、变量少;压测用于确定容量与端到端延迟;线上观测用于确认改动在真实流量下的效果。微基准的结论不能推出端到端收益:在一次请求的总耗时中,被测路径可能只占很小比例,局部提升会被其余环节摊薄。

二、原理

2.1 JIT 带来的测量陷阱

JVM 在运行过程中持续改变代码的执行形态。这些改变对业务是有益的,对测量则构成干扰源。

2.1.1 解释执行与即时编译的切换

HotSpot 采用解释器与即时编译器协作的混合模式:方法首次执行时由解释器逐条翻译字节码;方法调用次数或循环回边次数超过阈值后,方法被编译成本地机器码。JDK 8 起默认开启分层编译,执行形态按 C1(快速编译,带剖析数据)到 C2(深度优化)逐层演进,长循环还可通过栈上替换(On-Stack Replacement,OSR)在中途切换到编译版本。机制细节见 类加载机制与执行引擎 中执行引擎与 JIT 章节。

对测量的直接后果是:同一个方法在同一份代码中,不同轮次的耗时可能相差数倍,差异来自执行形态而不是代码变化。任何未经过预热就采集的数值,记录的都是"该轮恰好处于哪个编译层级"。

2.1.2 方法内联

内联把被调用方法的代码复制到调用点,既消除调用开销,也使常量传播、死代码消除等优化得以跨方法进行。内联决策与方法的字节码大小、调用频率、以及接收者类型是否可确定相关。

对测量的影响体现在两处:

  • 基准中被调用的方法通常小而固定,几乎必然被内联。测得的"方法调用成本"可能是内联之后剩余的部分,甚至不包含调用开销
  • 若为减少内联影响而人为把方法写大、或加入多层间接调用,测得的是生产中不存在的形态,结论同样不可用

2.1.3 常量折叠与死代码消除

基准方法若以编译期常量作为输入,且计算过程没有副作用,JIT 可以在内联之后把整个计算折叠为常量。

@Benchmark
public int constantInput() {
    // 参数都是编译期常量,内联后可被整体折叠
    return (int) Math.pow(2, 10);
}

@Benchmark
public void unusedResult() {
    // 结果未被使用且无副作用,调用可被消除
    "abcdef".indexOf("cd");
}

两个基准方法的耗时都会接近空方法。判定标准是"计算结果是否以任何可观测的方式离开被测代码":赋值给状态对象的字段、作为返回值交给调用方、写入数组或集合,才算真正被使用。框架侧的处理方式是黑洞(Blackhole),见 2.3。

2.1.4 循环优化

JIT 会做循环展开、循环不变量外提、循环向量化等优化。基准方法内自行编写的循环因此是最不可控的部分:循环体的实际执行次数、是否被展开、是否被整体消除,都取决于 JIT 的判断,而这些判断随循环体大小、迭代次数与有无副作用而变化。

处理方式是基准方法一次只执行一个操作,迭代循环由框架生成。需要测量批量操作时,用 @OperationsPerInvocation(n) 声明一次调用包含的操作数,由框架换算单位,而不是在方法内自行累加循环。

2.1.5 逃逸分析与栈上分配

逃逸分析判定对象的生命周期是否离开方法或线程。不逃逸的对象可以不做堆分配,而是把字段拆解为局部变量(标量替换),分配与随之而来的垃圾回收成本随之消失。机制见 JVM 内存结构与垃圾回收 中对象内存布局与栈上分配章节。

由此产生两类偏差:测"创建对象的成本"时,若对象不逃逸,测到的只是几条赋值指令;反过来,为了让对象逃逸而把它存入集合,除分配成本外还引入了容器的插入成本,此时测到的是另一种场景。基准代码需要明确回答"要测的是哪种生命周期",并把对应写法固定下来。

2.1.6 逆优化与预热不足

JIT 的激进优化建立在运行时假设之上,假设被打破时触发逆优化(Deoptimization),退回解释执行重新积累剖析数据,之后再重新编译。基准运行期间若发生类型变化、类加载或分支走向改变,会出现"中间某轮突然变慢"的现象。

预热的作用是让执行形态、剖析数据、类加载状态都进入稳态。判定预热是否充分不能只看轮次数量,而要看迭代结果是否已进入波动范围:连续若干轮数值没有单调趋势,才具备开始测量的条件。观察编译事件与编译状态的手段见 JDK 内置工具详解 的 JVM 监控与诊断工具章节;应用运行期的编译状态、线程栈与内存视图的采集方式见 Java 应用诊断与部署调优。

2.2 测量误差来源

误差来源 机制 对结果的影响
计时精度 时钟分辨率与读取开销 单次操作耗时接近分辨率时,数值由噪声主导
垃圾回收 测量窗口内发生回收 个别轮次耗时抬高一个数量级
CPU 调频 省电策略与温度引起的频率变化 同一组测量内出现缓慢漂移
线程调度 基准线程被抢占或跨核迁移 轮次之间的随机波动
其他进程 构建、索引、采集、其他基准 系统性偏高,且在对比两组基准时不易察觉
缓存与运行状态 页缓存、类文件读取、代码缓存 前段轮次偏慢,起始状态不一致

计时精度与时钟选择。 System.nanoTime 单调递增且不受系统时间调整影响,但分辨率由平台决定(常见在微秒量级),且每次调用有固定开销;System.currentTimeMillis 分辨率更低并可能被时间同步调整,不适合测量。当单次操作耗时低于时钟分辨率时,只能通过累计多次操作后取平均获得可比数值,判断方式是把测得的单次值与该平台的分辨率对照。

垃圾回收。 年轻代回收触发时,业务线程被暂停、存活对象被复制,落在测量窗口内会显著抬高该轮数值。分配速率高的基准更易受影响,回收次数又与堆大小、回收器、分配模式相关。处理方式是固定堆与回收器参数,并把分配量作为结论的一部分记录,而不是只比较耗时。

CPU 频率与调频。 省电调频器在负载突变时存在升频延迟,睿频受温度与功耗限制,多核负载下各核频率还可能不同。结果是同一份代码在不同时刻的耗时不同,且差异随环境温度变化。记录调频策略、尽量在性能档位下测量,可减小该影响,调频器与相关观测手段见 Linux 硬件拓扑与固件管理 的电源与调频章节。

线程调度与争用。 操作系统可能在任何时刻抢占基准线程,或在多核之间迁移它以均衡负载。单线程基准理想状态下运行在空闲核上;多线程基准需注意线程数不超过可用核数,否则测量的是排队而不是计算。

其他进程干扰。 同一台机器上的构建、IDE 索引、监控采集、其他基准进程都会占用 CPU 与内存带宽。这类干扰不是随机噪声,而是持续抬高结果,且在对比两组基准时表现一致,容易被忽略。

操作系统缓存状态。 首轮迭代需要读取类文件、填充代码缓存、建立 JIT 剖析数据,起始状态与后续轮次不同;访问文件的基准还受页缓存状态影响。处理思路与压测中的干扰控制一致:固定条件、明确预热、一次只改一个变量、多轮取稳态值,方法见 linux: 压测与性能基线 中基线与可控变量章节。

高危:为降低抖动而修改主机调频策略或空闲状态,例如 cpupower frequency-set -g performance、关闭深层 C-State、在 BIOS 中锁定频率。影响:主机功耗与温度上升,散热不足时反而触发降频使结果更不稳定;部分平台在深层 C-State 下存在稳定性问题;该设置作用于主机上的全部进程,忘记回退会使日常运行的功耗与延迟特征长期改变。要求:仅在专用于基准的机器上执行,执行前记录当前的 scaling_governor 与 BIOS 相关选项,测量结束后逐项回退;日常开发机上的做法是把频率波动纳入误差范围,并用 turbostat 记录测量期间的频率数值作为结论的附带信息。

2.3 JMH 的设计应对

JMH(Java Microbenchmark Harness)是 OpenJDK 提供的基准框架,其设计目标就是逐项消除上一节列出的干扰。

测量陷阱 JMH 的应对
预热不足 预热轮次与测量轮次分离,预热结果不进入统计
死代码消除 黑洞消费结果,使计算结果真正离开被测代码
常量折叠 输入来自状态对象的字段或 @Param,运行期取值
手工循环不可控 迭代循环由框架生成,@OperationsPerInvocation 换算单位
GC 与 JIT 状态串扰 @Fork 启动独立 JVM 进程,每个进程独立预热
共享状态干扰 @State 与作用域声明实例粒度,@Setup/@TearDown 管理生命周期
单次结果不可信 多次迭代产生样本,输出统计量与置信区间
参数组合繁多 @Param 声明参数取值,命令行可覆盖

预热与测量轮次的分离。 框架先执行若干预热迭代,再执行测量迭代,只有测量迭代的结果参与统计。每轮迭代的时长下限由框架保证(默认以秒计),避免单轮样本过少。

结果的强制消费。 基准方法返回非 void 时,框架会通过黑洞消费返回值。返回 void 的基准方法(例如测副作用或写操作)需显式接收 Blackhole 参数并调用 consume。黑洞的实现保证写入不被优化掉,同时其自身开销被控制在可忽略的量级。

状态与作用域。 @State 标注的类持有基准所需的字段,作用域决定实例数量与共享方式:

作用域 实例数 共享关系 适用
Scope.Benchmark 每个 fork 一个 全部基准线程共享 只读的输入数据
Scope.Thread 每个线程一个 线程独享 有状态的对象、缓冲区
Scope.Group 每个线程组一个 组内共享 需要协作的并发场景,配合 @Group

@Setup 与 @TearDown 的执行层级决定初始化成本被计入的位置:Level.Trial 在每个 fork 开始时执行一次,适合构造数据集;Level.Iteration 每轮迭代执行一次,适合需要固定初始状态的场景;Level.Invocation 每次调用执行一次,其自身开销会进入测量范围,仅在确实需要时使用。

分叉进程隔离。 @Fork(1) 表示框架另起一个 JVM 进程执行基准,主进程只负责汇总。分叉的价值在于把 JIT 编译历史、GC 堆状态、代码缓存内容隔离在基准进程内:同一进程内连续运行多个基准时,前一个基准的编译状态会改变后一个基准的执行形态。多分叉(例如取 3)可得到多组独立样本,用于观察结果是否稳定。

多样本与置信区间。 每轮测量迭代产生一个样本,框架输出样本均值与误差范围。误差范围反映本组样本的离散程度,不是绝对精度,因此"误差小"只说明本组测量稳定,不代表结论正确。

参数化与分组。 @Param 把输入规模、实现选项等维度声明为参数,框架按组合展开为多个基准并分别报告,便于观察趋势而不是比较单点。@Group 与 @GroupThreads 用于表达多线程协作的基准,例如一组线程读、一组线程写,各组分别统计。

2.4 基准模式

框架提供四种测量模式,选择依据是"关心的量是吞吐还是单次延迟"以及"是否需要分布"。

模式 单位 含义 适用场景 主要局限
Throughput 操作数/时间 单位时间内完成的操作数 批处理、转换、扫描类逻辑 不反映单次延迟,也不反映长尾
AverageTime 时间/操作 单次操作的平均耗时 延迟敏感调用的常规比较 平均值掩盖分布,长尾不可见
SampleTime 时间/操作的分布 按采样得到的耗时分布与分位数 关注抖动与长尾 需要更大样本量,报告字段更多
SingleShotTime 时间/操作 每次调用单独测量 冷启动、一次性初始化、类加载成本 单次样本噪声大,需配合预热轮次为 0 与多次分叉

选择顺序上先确定关心的量:调用方按次等待结果的路径关注 AverageTime,批量处理的路径关注 Throughput;只有当"偶发慢是否严重"本身是问题时才使用 SampleTime。SingleShotTime 的用途与前三种不同,它测的是冷路径成本,配置中应把预热轮次设为 0,否则冷路径在预热阶段已被消耗。

2.5 结果判读

平均值与分位数。 AverageTime 报告的是各轮迭代样本的均值,不是单次操作的分布;只有 SampleTime 提供分位数。把 AverageTime 的结果当作"绝大多数请求的耗时"是常见的误读。

误差范围与统计显著性。 报告中的 ± 为样本的置信区间半宽。判读规则是:两组结果的置信区间存在重叠时,不能判定两者存在差异;差值的量级需要显著大于两组误差,结论才成立。区间不重叠只是必要条件,还应通过复跑确认结果可复现。

模式间的换算。 Throughput 与 AverageTime 在单线程、无并发重叠的条件下互为倒数,可以互相核对。多线程或存在流水线重叠时该关系不成立:此时吞吐由并行度决定,平均耗时反映的是单次操作在争用下的等待时间,两者不能互相推导。

结论的适用边界。 基准结果不可直接外推的原因有四项:被测输入规模通常小于生产;缓存局部性优于生产;异常路径、并发与 I/O 被简化或替换;JDK 与依赖版本在基准与生产之间可能不同。结果的正确表述是"在该输入规模与该 JDK 版本下,实现 A 的单次成本约为实现 B 的 N 倍",而不是"实现 A 更快"。

2.6 与其他方法的对照

方法 观测对象 回答的问题 结论可信范围 主要手段
微基准 方法或代码路径 哪种实现局部更省 该版本、该规模下的相对比较 JMH 等基准框架
系统压测 服务与主机 能承载多少、延迟分位如何 该环境与配置下的容量边界 压测工具与资源观测
线上观测 真实流量 变更后实际表现如何 当前数据分布下的真实结果 指标、日志、追踪

三者的推进顺序是:微基准在候选实现之间筛选,压测确认容量与端到端延迟,线上观测验证真实影响。容量与延迟目标的确定方法见 linux: 压测与性能基线;线上出现性能问题时的定位路径与本文的测量方法分工不同,前者从现象出发逐层排除,手段是采样、动态追踪与转储,见 Java 应用诊断与部署调优。

三种方法的结果要能互相印证,前提是口径一致(单位、分位定义、统计窗口),口径要求见 Java 应用观测与埋点实践 与 linux: 监控与告警。

三、实现

3.1 环境准备

依赖与构建集成。 基准需要两个构件:jmh-core 提供运行期框架,jmh-generator-annprocess 在编译期生成基准代码,其机制与注解处理器的注册方式见 Java 注解处理与编译期代码生成。基准代码应放在独立模块或独立源码集,不进入生产制品。

Maven 侧配置示例:

<properties>
    <jmh.version>1.37</jmh.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.openjdk.jmh</groupId>
        <artifactId>jmh-core</artifactId>
        <version>${jmh.version}</version>
    </dependency>
    <dependency>
        <groupId>org.openjdk.jmh</groupId>
        <artifactId>jmh-generator-annprocess</artifactId>
        <version>${jmh.version}</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>3.5.1</version>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                    <configuration>
                        <finalName>benchmarks</finalName>
                        <transformers>
                            <transformer
                                implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                <mainClass>org.openjdk.jmh.Main</mainClass>
                            </transformer>
                        </transformers>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

版本号应与项目依赖管理统一,上述数值仅为示例;依赖声明方式、插件绑定阶段与多模块划分的原则见 Gradle 与 Java 构建流水线。Gradle 侧的做法是建立独立的 jmh 源码集并声明与之对应的依赖配置,或使用社区维护的 jmh 插件,此处不展开。

编译与运行。 打包为可执行 jar 后单独启动,以便完整控制进程参数:

# 打包,同时完成注解处理与基准代码生成
mvn -pl benchmarks clean package

# 列出全部基准,确认生成结果
java -jar target/benchmarks.jar -l

# 运行并输出 json 结果
java -jar target/benchmarks.jar -f 2 -wi 5 -i 5 -rf json -rff result.json

不建议在 IDE 中直接运行基准:调试器、附加的 agent 与 IDE 的运行配置都会改变 JIT 与 GC 行为,且 IDE 进程自身占用 CPU。

运行参数与分叉设置。 注解给出的是默认值,命令行参数用于临时调整与复现,二者的对应关系见 3.3。约定是:稳定的配置写入注解并随代码版本管理,实验性的调整通过命令行传入并记录在结论中。

3.2 基准编写实践

一个完整的基准由状态类、参数、准备方法与若干基准方法组成。

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 5, time = 1)
@Fork(2)
@State(Scope.Thread)
public class StringJoinBenchmark {

    @Param({"10", "100", "1000"})
    private int elementCount;

    private String[] fragments;

    @Setup(Level.Trial)
    public void prepare() {
        fragments = new String[elementCount];
        for (int i = 0; i < elementCount; i++) {
            fragments[i] = "fragment-" + i;
        }
    }

    @Benchmark
    public String stringBuilder() {
        StringBuilder builder = new StringBuilder(elementCount * 8);
        for (String fragment : fragments) {
            builder.append(fragment);
        }
        return builder.toString();
    }

    @Benchmark
    public String stringJoin() {
        return String.join("", fragments);
    }
}

结构要点:

  1. 基准方法只执行一次完整操作,返回值交给框架消费。不写成"循环 N 次再取平均",也不在方法内写计时语句。若被测操作本身是批量语义,用 @OperationsPerInvocation 声明每次调用的操作数
  2. 输入数据在 @Setup 中构造,数据集构造成本不计入测量。数组元素是运行期拼接出的字符串,避免编译期常量被折叠
  3. elementCount 作为 @Param,使结果按规模展开,可观察差异是否随规模变化
  4. 状态作用域为 Scope.Thread,每个基准线程持有独立的 fragments 引用,避免共享可变状态

返回 void 的基准需要显式消费结果:

@Benchmark
public void parseAndConsume(Blackhole blackhole) {
    blackhole.consume(JsonParser.parse(fragments[0]));
}

其余实践约束:

  • 基准方法内不写日志、断言、条件分支与埋点。分支会随输入改变热点路径,日志与断言引入 I/O 与锁
  • 不把异常当作正常路径:异常构造与栈填充的成本远高于被测逻辑
  • 共享状态若在多线程下被写入,应改为 Scope.Thread 或明确加同步,并把同步成本视为被测对象的一部分
  • 一个基准类只比较同一组互相替代的实现,避免无关实现互相影响编译状态
  • 对照用的"空基准"用于估计框架与循环本身的开销,但它同样可能被 JIT 消除,其数值是否可信需结合黑洞的使用判断

3.3 常用配置

配置项 注解 命令行 取值依据
预热 @Warmup(iterations, time) -wi、-w 迭代结果进入波动范围后再开始测量
测量 @Measurement(iterations, time) -i、-r 单轮时长足够长以摊平抖动,通常以秒计
分叉 @Fork(n) -f 至少 1;需要多组独立样本时取 3
线程 @Threads(n) -t 不超过可用核数,与作用域配合
模式 @BenchmarkMode -bm 见 2.4
单位 @OutputTimeUnit -tu 只影响可读性,不影响测量
参数 @Param -p name=v1,v2 覆盖决策相关的规模区间
进程参数 @Fork(jvmArgsAppend) -jvmArgsAppend 固定堆与回收器
结果输出 -rf json -rff file 便于归档与脚本对比
剖析器 -prof gc、-prof stack 需要分配量或调用栈归因时启用

堆与回收器参数需要在分叉进程上固定,并与结论一同记录:

java -jar target/benchmarks.jar \
  -f 2 -wi 5 -i 5 -t 1 \
  -jvmArgsAppend "-Xms1g -Xmx1g -XX:+UseG1GC" \
  -prof gc \
  -rf json -rff result-20260923.json

固定 -Xms 与 -Xmx 相等可避免测量过程中堆扩容触发额外回收;启用 -prof gc 后结果中会附带每操作的分配量(gc.alloc.rate.norm),当两种实现的耗时接近而分配量相差明显时,该字段给出选型依据。

高危:为做对比而修改 JVM 参数,包括在共享环境或生产进程中关闭分层编译(-XX:-TieredCompilation)、关闭逃逸分析(-XX:-DoEscapeAnalysis)、调整堆与回收器,或开启诊断与日志选项(-XX:+PrintCompilation、-Xlog:gc*)。影响:这些参数会改变执行形态与内存行为,在生产进程上可能造成吞吐下降、延迟抖动甚至内存结构异常;参数一旦写入生产启动脚本与配置中心,会长期影响全部实例,且从业务指标上难以察觉。要求:对比实验只在基准进程内通过 @Fork(jvmArgsAppend) 或一次性命令行生效,不写入生产启动脚本与配置中心;确需在生产验证某项参数时,通过变更流程在单个实例灰度,并同时观测吞吐与延迟分位。

3.4 场景设计

集合选型对比。 目标是回答"在给定规模与访问模式下,哪种集合更低"。设计要点:

  • 数据准备与填充在 @Setup 中完成;若被测操作包含插入,则单独设计基准,不与其他操作混在一次测量中
  • 键的构造注意哈希缓存:String 的哈希值在首次计算后被缓存,同一批键在预热之后不再计算哈希,需要比较哈希成本时应单独测量
  • 规模作为 @Param,复杂度差异只在大规模下显现,小规模下常数因子更显著
  • 遍历方式的差异属于同一组对照(索引、迭代器、流),复杂度差别见 集合框架内部实现 的遍历与性能章节
  • 用于选型时同时看吞吐与分配量

字符串拼接。 对照 +、StringBuilder、String.join 等写法。设计要点:

  • 编译期常量拼接会被编译器直接合并为常量,参与对照的必须是运行期值(字段、参数、方法返回值)
  • 元素数量作为参数,观察差异随规模的变化
  • 预设容量与未预设容量的 StringBuilder 应分别测量,扩容成本是差异的主要来源

序列化方案对比。 对照文本格式与二进制格式、不同库之间的开销。设计要点:

  • 被测对象模型固定,字段类型覆盖字符串、数值、集合与时间,避免只测简单结构
  • 序列化与反序列化分别建立基准,两者的成本结构不同
  • 序列化器实例的创建放在 @Setup;库内部使用线程不安全缓冲区时用 Scope.Thread
  • 序列化配置(字段命名、时间格式、是否忽略未知字段)需固定并记录,否则库之间的差异来自配置而非实现
  • 输出字节大小属于结论的一部分,开销与体积需要一起看,格式差异与选型考量见 序列化与反序列化

锁与并发结构对比。 对照 synchronized、ReentrantLock、无锁结构与各种并发容器。设计要点:

  • 单线程下测量锁没有意义:无竞争的锁会被消除或退化为极轻量路径,测不到争用成本
  • 并发对比需固定线程数并声明 Scope.Thread 的状态,@Group 用于表达读写混合的协作模型
  • 模式选择以 Throughput 为主,同时记录操作发生在同核还是跨核,跨核争用成本与核数、拓扑相关
  • 两种结构应在同一台机器、同一时段内连续测量,交错运行会互相污染编译状态
  • 锁的行为与硬件、JDK 版本强相关,结论只在该版本下成立,并发机制基础见 Java 并发编程

算法改写的效果验证。 用于确认"把 O(n²) 改为 O(n log n)"这类改动在真实规模下确实带来收益。设计要点:

  • 输入规模覆盖决策相关的区间,并观察曲线形态:只有优势随规模扩大而增大时,复杂度分析的结论才被证实
  • 输入分布至少覆盖平均与最坏两种,随机数据会掩盖分支预测与缓存局部性带来的差异
  • 改写前后的公共前置处理保持一致,并放在 @Setup 中

设计与注意点清单

  1. 一次只改变一个变量,其余条件(数据、JDK、进程参数、机器状态)保持一致
  2. 数据构造不进入测量范围,测量范围只包含决策关心的那一步
  3. 参与对照的实现调用生产代码的同一份依赖与版本
  4. 规模参数覆盖"最小可接受规模"到"预期峰值规模"
  5. 每种配置至少分叉两次,检查多组样本是否一致
  6. 记录 JDK 版本、CPU 型号、堆与回收器参数、命令行与执行时间
  7. 结论同时给出耗时与分配量,两者趋势不一致时必须解释差异来源

3.5 结果分析与结论表述

判断差异是否显著。 步骤如下:

  1. 比较两组结果的置信区间,重叠即不能判定存在差异
  2. 计算差值倍数并与误差范围对比;差值小于误差范围的 2 至 3 倍时,需追加轮次或提高分叉数
  3. 复跑一次确认结论可复现;同一份代码在不同时段得到相反结论时,先把原因查清再下结论
  4. 差异显著时还要判断它对决策是否有意义:被测路径在端到端耗时中的占比、被优化掉的绝对时间,决定了局部提升是否有实际收益

结论的表述方式。 结论需要包含被测内容、条件与数值三部分。结果文件为 json 格式,节选如下:

[
  {
    "benchmark": "StringJoinBenchmark.stringBuilder",
    "mode": "avgt",
    "params": { "elementCount": "1000" },
    "primaryMetric": {
      "score": 456.789,
      "scoreError": 4.567,
      "scoreUnit": "ns/op"
    }
  },
  {
    "benchmark": "StringJoinBenchmark.stringJoin",
    "mode": "avgt",
    "params": { "elementCount": "1000" },
    "primaryMetric": {
      "score": 1234.567,
      "scoreError": 12.345,
      "scoreUnit": "ns/op"
    }
  }
]

对应的表述是:"在 JDK 17、elementCount=1000、平均耗时模式下,StringBuilder 的单次拼接耗时约为 String.join 的三分之一,两组结果的置信区间不重叠。"应当避免的表述包括:"StringBuilder 性能最好"(未限定条件)、"拼接 1000 个元素只需 0.45 微秒"(未说明统计口径与误差)、"用该实现可以支撑每秒百万次调用"(把局部结论外推为容量结论)。

归档方式。 基准代码与结果一同纳入版本管理:

benchmarks/
├── src/main/java/...                 基准源码
├── result-20260923-jdk17.json        结果文件(含环境与统计信息)
├── cmd.txt                           完整命令行
└── notes.md                          结论、限定条件与待确认项

结果文件与提交号、JDK 版本对应,便于多轮对比;一次性实验的结果不必入库,但其命令行与环境信息需要保留在结论中。

回归基准的建立与执行时机。 把少量与业务直接相关、波动小的基准作为回归项,用于发现"某次依赖升级或重构导致局部成本上升"。要点:

  • 执行时机放在合并前的流水线或定时任务中,而不是每次提交都执行:基准耗时较长且对机器状态敏感,与单元测试混跑会互相影响
  • 回归判定阈值来自历史波动统计,不使用固定百分比;阈值过紧会产生误报,过松会漏掉退化
  • 失败时的处置与测试失败一致:先确认是否由同一变更引入,再决定修实现或更新基线,禁止直接放宽阈值
  • 回归基准在流水线中的位置、与测试分层和门禁强度的关系参照 Java 测试体系 的 CI 章节;结果作为趋势指标的记录方式(口径统一、趋势优先于单点、归档保留周期)参照 Java 应用观测与埋点实践

3.6 常见误用与排查

误用 表现 纠正
未预热下结论 前几轮数值被当作结果,或改写后一方恰好更晚触发编译 以迭代结果进入波动范围为开始测量的条件;使用框架预热轮次并检查每轮输出
把微基准结论用于容量规划 由"单次 0.5 微秒"推出"单实例每秒可处理两百万次" 容量结论来自压测;微基准只用于实现之间的相对比较
忽略 GC 与内存分配 耗时差异实际来自分配量与回收次数,而非算法 固定堆与回收器,启用 -prof gc 并同时报告分配量
基准路径与生产不一致 依赖版本、配置、数据规模或异常路径不同 复用生产依赖与配置;对关键差异逐项记录并在结论中声明
测量环境不稳定 构建、索引、其他基准同时运行;频率与温度变化 使用基准专用机器或空闲时段;同一时刻只运行一个基准进程
结果不可复现 未记录参数与环境,或使用未固定的随机数据 命令行、JDK 版本、机器信息与结果一同归档;随机数据使用固定种子

结果异常时按以下顺序排查:

  1. 确认基准方法是否真的在被执行:判断是否被 JIT 消除,数值是否为空方法量级
  2. 确认预热是否充分:查看每轮迭代输出是否平稳
  3. 确认环境是否一致:其他进程、频率、温度、后台任务
  4. 确认进程参数是否一致:分叉数、堆、回收器、线程数
  5. 仍未解释时,保留原始输出并按未决项记录,等待复测确认

高危:在生产实例或生产主机上运行基准程序,包括在业务进程内以定时任务触发基准、在容器内与业务共用 JVM 运行基准、以及在承载线上流量的主机上直接启动基准 jar。影响:基准线程与业务线程争抢 CPU 会直接抬高线上延迟;额外分配触发更频繁的回收;代码缓存被基准代码填充、JIT 编译线程被占用,可能挤占业务方法的编译额度并引起去优化;诊断与日志选项还会带来额外开销。要求与替代做法:基准在独立的开发或测试环境执行;需要复现生产特征时使用同一镜像与配置的独立实例,并按资源份额限制基准进程(例如 systemd-run --property=CPUQuota=...),执行窗口纳入变更流程,资源约束方式见 linux: 压测与性能基线 的高危提示。

3.7 规范与检查清单

基准代码评审要点

  • 被测路径与生产调用的是同一份实现与依赖版本,差异项已记录
  • 基准方法的返回值被消费,不存在无副作用的空基准被当作测量对象
  • 输入数据在 @Setup 中构造,数据规模覆盖决策相关区间
  • 状态作用域与被测语义一致,多线程基准中的共享状态有明确处理
  • 预热与测量轮次的规模足以使迭代结果进入波动范围,分叉数不少于 1
  • 进程参数(堆、回收器、线程数)显式声明并与结论一同记录
  • 结论包含数值、误差范围与限定条件,未出现无条件的最优性表述

结论引用要求

  1. 引用基准结论时给出基准名称、参数取值、JDK 版本、测量模式与单位
  2. 不把微基准结论作为容量、服务水平目标或扩容决策的依据
  3. 引用既有文档或他人给出的基准数值时,先确认其成立条件是否与当前场景一致。例如"反射调用比直接调用慢一个数量级"这类量级结论与 JDK 版本相关,量级参考见 Java 反射机制
  4. 基准数值随环境变化,跨机器、跨版本的数值不做直接比较

何时不该做微基准

  • 端到端指标已经能回答问题:某接口耗时下降且原因明确时,无需再做方法级测量
  • 成本主要来自 I/O、网络、数据库或外部服务:此时 JVM 内的测量只覆盖解析与驱动层,端到端成本由下游与执行计划决定,数据访问层的成本构成见 Java 持久层
  • 被测路径无法被完整隔离:依赖外部服务、容器或全链路上下文时,替身会改变被测行为
  • 差异量级小于测量噪声:两种实现的理论差异与框架开销、GC 波动同量级时,基准无法给出稳定结论
  • 改动本身不以性能为目标:可读性与正确性优先的重构不必以基准结果为依据

四、总结

  1. 微基准回答的是"同一功能的两种实现哪个局部成本更低",不回答容量与端到端收益,结论只在该 JDK 版本、输入规模与配置下成立
  2. 手写计时的失效来自预热不足、死代码消除与常量折叠、计时开销与外部干扰,这些问题无法靠增加运行次数消除
  3. JIT 是主要干扰源:执行形态切换、内联、常量折叠、循环优化、逃逸分析与逆优化都会改变被测对象的形态,未预热的结果记录的是编译层级而不是代码性能
  4. JMH 的设计逐项对消这些干扰:分离预热与测量轮次、黑洞强制消费结果、状态与作用域控制共享、分叉隔离 JVM 状态、多样本给出置信区间、参数化展开规模
  5. 模式选择由关心的量决定:批处理看吞吐,逐次调用看平均耗时,抖动与长尾看采样,冷路径看单次执行
  6. 结果判读的核心是误差范围:置信区间重叠不能判定差异,模式之间的换算只在单线程无重叠时成立,局部结论不可外推
  7. 基准代码要复现生产路径:同一依赖版本与配置、规模覆盖决策区间、状态作用域与被测语义一致,并同时记录耗时与分配量
  8. 修改 JVM 参数做对比、切换主机调频策略、在生产环境运行基准三类操作的影响范围超出测量本身,需限定在专用环境执行并在结束后回退
  9. 结论表述需带条件与数值,引用时给出基准名称、参数、JDK 版本与模式;微基准结论不作为容量依据
  10. 微基准与压测、线上观测三者分工明确:微基准筛选实现,压测确定容量与端到端延迟,线上观测验证真实效果,口径一致时三者可互相印证