一个能提升速度500+倍的 Java 知识点

aukocharlie

待测对象

public class StaticExample {
    static final long[] TABLE = new long[100_000];

    static {
        long start = System.currentTimeMillis();
        TABLE[0] = 0;
        for (int i = 1; i < TABLE.length; i++) {
            nextValue(i);
        }
        System.out.printf("Cost of static example: %sms%n", System.currentTimeMillis() - start);
    }

    private static void nextValue(int index) {
        TABLE[index] = TABLE[index - 1] * 0x123456789L + 11;
    }
}

public class NonStaticExample {
    final long[] TABLE = new long[100_000];

    {
        long start = System.currentTimeMillis();
        TABLE[0] = 0;
        for (int i = 1; i < TABLE.length; i++) {
            TABLE[i] = nextValue(TABLE[i - 1]);
        }
        System.out.printf("Cost of non-static example: %sms%n", System.currentTimeMillis() - start);
    }

    private static long nextValue(long seed) {
        return seed * 0x123456789L + 11;
    }
}

然后 new 一下它两

public static void main(String[] args) {
    new StaticExample();
    new NonStaticExample();
}

输出

Cost of static example: 1676ms
Cost of non-static example: 3ms

看到结果，我直呼离谱

解答

Beware of computation in static initializer

Miigon

性能差距是在nextValue()方法的内联与否上

我自己测试的时候有一个有趣的发现：
使用 OpenJDK 15.0.2 的话，其实 static 与 non-static 性能差距是没有 11.0.2 上那么大的

# 均为5次运行取中位数

# OpenJDK 15.0.2
Cost of static example: 16ms
Cost of non-static example: 3ms

# OpenJDK 14
Cost of static example: 21ms
Cost of non-static example: 3ms

# OpenJDK 11.0.2
Cost of static example: 694ms
Cost of non-static example: 2ms

使用 OpenJDK 15.0.2 进行分析的话，可以看到在 15.0.2 上，Static版本的 nextValue() 和 11.0.2 上一样也是无法内联的。

miigon$ java -XX:+PrintCompilation -XX:+UnlockDiagnosticVMOptions -XX:+PrintInlining Main | grep nextValue
     34   35       3       StaticExample::nextValue (21 bytes)
     34   36       4       StaticExample::nextValue (21 bytes)
     35   35       3       StaticExample::nextValue (21 bytes)   made not entrant
                              @ 28   StaticExample::nextValue (21 bytes)   not inlineable  #这里
                              @ 28   StaticExample::nextValue (21 bytes)   not inlineable
     80  121       3       NonStaticExample::nextValue (10 bytes)
     80  122       4       NonStaticExample::nextValue (10 bytes)
     81  121       3       NonStaticExample::nextValue (10 bytes)   made not entrant
                              @ 47   NonStaticExample::nextValue (10 bytes)   inline
                              @ 47   NonStaticExample::nextValue (10 bytes)   inline

不理解 15.0.2 是如何做到不内联也性能差别如此小，个人猜测有可能是：11.0.2 上的 static 版本内不仅 nextValue() 没有内联，或许整个 static 代码块都没有 JIT 编译就执行了，而 15.0.2 上可能有对 static 代码块进行 JIT。不过这个没有 profile 的话也只是猜测。

aukocharlie

Miigon 或许整个 static 代码块都没有 JIT 编译就执行了

应该是这样的，文章其实有提到

It turns out that access to a static field from a static method of uninitialized class may be an overwhelming obstacle for HotSpot compiler.

简单地说就是访问静态字段导致的 deoptimization

该 bug 是已知的，且在 OpenJDK 13 中解决（patch），但是无法适用 11u （原因）

Miigon

这么看来其实，为了性能而采用文章内提到的 helper class 的方法已经没多大必要了。static 数据的初始化也算不上高频操作，还是简洁和可读性重要。