多次调用 Method/Field.getAnnotation(Class) 与在 Map 中预缓存此数据的性能

Question

我想知道是否有关于重复调用（在Java中）Method.getAnnotation(Class)和Field.getAnnotation(Class) 方法，而不是存储（在程序启动时）带有类的元数据信息的预先计算的 Map 并稍后重复查询。哪一种可以提供最佳的运行时性能？

这个性能在 Java 5、6 和 7 下是一样的吗？

Answer 1

地图应该是一种更可取的方法。主要问题不仅仅是缓存。而且还改善了多线程争用。在Method.getAnnotation()中，它调用同步私有方法declaredAnnotations()。同步方法对高线程应用程序有不好的影响。

Answer 2

我知道这是一个相当老的问题，但最新 JDK 的结果可能仍然令人感兴趣。

我编写了一些 JMH 基准测试，以了解注释信息缓存可能产生的影响：

@State(Scope.Thread)
public static class StateWithMethodAndHashMap {
    public StateWithMethodAndHashMap() {
        try {
            cache = new HashMap<>();
            method = AnnotationCachingBenchmark.class.getMethod("methodWithAnnotations");
            final Annotation annotation = method.getAnnotation(Deprecated.class);
            cache.put(method, annotation);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    final HashMap<Method, Annotation> cache;
    final Method method;
}

@State(Scope.Thread)
public static class StateWithMethodAndConcurrentHashMap {
    public StateWithMethodAndConcurrentHashMap() {
        try {
            cache = new ConcurrentHashMap<>();
            method = AnnotationCachingBenchmark.class.getMethod("methodWithAnnotations");
            cache.put(method, method.getAnnotation(Deprecated.class));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    final ConcurrentHashMap<Method, Annotation> cache;
    final Method method;
}

@State(Scope.Thread)
public static class StateWithMethod {
    public StateWithMethod() {
        try {
            method = AnnotationCachingBenchmark.class.getMethod("methodWithAnnotations");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    final Method method;
}

@Deprecated
public void methodWithAnnotations() {
}

@Benchmark
@BenchmarkMode(Mode.All)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public void annotationsByReflection(final Blackhole aBh, final StateWithMethod aState) throws Exception {
    aBh.consume(aState.method.isAnnotationPresent(Deprecated.class)
            || aState.method.getClass().isAnnotationPresent(Deprecated.class));
}

@Benchmark
@BenchmarkMode(Mode.All)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public void annotationsByHashMap(final Blackhole aBh, final StateWithMethodAndHashMap aState) throws Exception {
    aBh.consume(aState.cache.get(aState.method));
}

@Benchmark
@BenchmarkMode(Mode.All)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public void annotationsByConcurrentHashMap(final Blackhole aBh, final StateWithMethodAndConcurrentHashMap aState)
        throws Exception {
    aBh.consume(aState.cache.get(aState.method));
}

JDK 1.8.0_172、Java HotSpot(TM) 64 位服务器 VM、25.172-b11：

Benchmark                                                   Mode    Cnt      Score      Error   Units
AnnotationCachingBenchmark.annotationsByConcurrentHashMap  thrpt      5      0.152 ±    0.009  ops/ns
AnnotationCachingBenchmark.annotationsByHashMap            thrpt      5      0.144 ±    0.005  ops/ns
AnnotationCachingBenchmark.annotationsByReflection         thrpt      5      0.043 ±    0.001  ops/ns

AnnotationCachingBenchmark.annotationsByConcurrentHashMap   avgt      5      6.610 ±    0.094   ns/op
AnnotationCachingBenchmark.annotationsByHashMap             avgt      5      6.963 ±    0.414   ns/op
AnnotationCachingBenchmark.annotationsByReflection          avgt      5     23.248 ±    0.339   ns/op

JDK 13、OpenJDK 64 位服务器 VM、13 +33：

Benchmark                                                   Mode    Cnt       Score      Error   Units
AnnotationCachingBenchmark.annotationsByConcurrentHashMap  thrpt      5       0.128 ±    0.027  ops/ns
AnnotationCachingBenchmark.annotationsByHashMap            thrpt      5       0.136 ±    0.031  ops/ns
AnnotationCachingBenchmark.annotationsByReflection         thrpt      5       0.139 ±    0.010  ops/ns

AnnotationCachingBenchmark.annotationsByConcurrentHashMap   avgt      5       7.335 ±    1.067   ns/op
AnnotationCachingBenchmark.annotationsByHashMap             avgt      5       6.634 ±    0.184   ns/op
AnnotationCachingBenchmark.annotationsByReflection          avgt      5       7.234 ±    0.567   ns/op

与 1.8 和 13 相比，您可以清楚地看到 JDK 缓存注释的效果。最近的 JDK 也是如此无需关心缓存此信息，因为它只会带来额外的开销。

Answer 3

我想这在一定程度上取决于 JVM 的实现。但以 Oracle JVM 为例，它维护了方法和字段实例上所有注释的缓存，这相当于你所说的映射方法。

但这里有一个问题：由于方法/字段实例对于每个对象都是唯一的，因此如果您最终为给定类创建大量对象，您几乎会失去所提供的性能优势。在这种情况下，类名+方法名/类名+字段名到相关注释列表的静态映射胜过所使用的内置缓存方法。

顺便说一句，你是如何预先计算地图的？是在应用程序启动时完成还是在某些自动生成的代码中完成？您是否真的确认在您的案例中缓存注释实例是安全的？

与往常一样，对于此类问题，最好的解决方案是使用您的应用程序在线进行分析/测量，并采用在给定用例中看起来像是胜利的解决方案。