如何在JMH基准测试中为ROT-13算法提供不计入耗时的随机输入？

好问题！针对你这个场景——既要给超快的ROT-13算法提供随机输入，又不能把随机字符串的生成开销计入基准测试耗时，同时还要避免分支预测干扰，有几个符合JMH最佳实践的方案可以参考：

方案一：预生成随机字符串池，循环取用 #

这个方案的核心是在基准测试阶段开始前一次性生成一批随机字符串，测试时循环使用这些字符串，完全避免了每次调用都生成新字符串的开销。

@State(Scope.Benchmark)
public class Rot13Benchmark {
    private String[] randomPlaintextPool;
    private int currentIndex;

    @Setup(Level.Trial)
    public void setupTrial() {
        // 生成足够多的随机字符串（比如1000个），覆盖整个测试周期的调用次数
        randomPlaintextPool = new String[1000];
        for (int i = 0; i < randomPlaintextPool.length; i++) {
            randomPlaintextPool[i] = randomString();
        }
        currentIndex = 0;
    }

    @Benchmark
    public String rot13Benchmark() {
        // 循环取用池中的字符串，避免分支预测偏差
        String plaintext = randomPlaintextPool[currentIndex];
        currentIndex = (currentIndex + 1) % randomPlaintextPool.length;
        return rot13(plaintext);
    }

    // 你的随机字符串生成方法
    private String randomString() {
        // 示例：生成固定长度的随机小写字母串
        int length = 32;
        StringBuilder sb = new StringBuilder(length);
        Random random = new Random();
        for (int i = 0; i < length; i++) {
            char c = (char) ('a' + random.nextInt(26));
            sb.append(c);
        }
        return sb.toString();
    }

    // 你的ROT-13实现
    private String rot13(String input) {
        StringBuilder sb = new StringBuilder(input.length());
        for (char c : input.toCharArray()) {
            if (c >= 'a' && c <= 'm') c += 13;
            else if (c >= 'n' && c <= 'z') c -= 13;
            sb.append(c);
        }
        return sb.toString();
    }
}

为什么这个方案可行？ #

• @Setup(Level.Trial) 只会在整个基准测试阶段（一次trial）开始前执行一次，生成字符串池的开销完全不会计入每个rot13Benchmark调用的耗时。
• 循环取用字符串池的操作是简单的数组索引和取模，几乎没有性能开销，也不会触发分支预测偏差（因为是固定顺序循环，无条件判断）。
• 池的大小足够大时，能避免JIT对特定字符串的过度优化，保证测试结果贴近真实场景。

方案二：线程本地字符串队列（适合多线程测试） #

如果你的基准测试是多线程运行的，用线程本地队列可以避免线程竞争，同时每个线程拥有独立的随机字符串池：

@State(Scope.Benchmark)
public class Rot13Benchmark {
    private ThreadLocal<Deque<String>> textQueue;

    @Setup(Level.Trial)
    public void setupTrial() {
        textQueue = ThreadLocal.withInitial(() -> {
            Deque<String> queue = new ArrayDeque<>();
            // 给每个线程预生成500个随机字符串
            for (int i = 0; i < 500; i++) {
                queue.add(randomString());
            }
            return queue;
        });
    }

    @Benchmark
    public String rot13Benchmark() {
        Deque<String> queue = textQueue.get();
        // 取出队列头部的字符串
        String plaintext = queue.pollFirst();
        // 循环补充队列（也可以提前生成足够多的字符串，避免在基准方法里生成）
        queue.addLast(randomString());
        return rot13(plaintext);
    }

    // 省略randomString和rot13方法，同方案一
}

注意点 #

如果担心补充字符串的操作影响耗时统计，建议直接预生成两倍于测试所需的字符串，循环取用即可，无需在基准方法内执行生成逻辑。

为什么不能用@Setup(Level.invocation)？ #

正如你看到的文档警告：这个级别会每次调用被测方法前都执行一次setup，而ROT-13的耗时远小于1毫秒，生成随机字符串的开销会完全掩盖ROT-13的真实执行时间，导致基准测试结果完全失真。

内容的提问来源于stack exchange，提问作者David says Reinstate Monica