非静态VarHandle性能劣于Field.get，求通用高性能替代方案

尝试用VarHandle替换java.lang.reflect.Field.get调用以提升性能，但实际性能反而下降。基准测试显示：

• 静态VarHandle性能优于Field.get
• 非静态VarHandle性能比Field.get慢约一倍

由于业务场景需要适配未知类（比如序列化场景），无法使用静态VarHandle，求性能优于Field.get的替代方案。

基准测试代码 #

import org.openjdk.jmh.annotations.*;
import java.lang.invoke.*;
import java.lang.reflect.Field;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 200, time = 10, timeUnit = TimeUnit.MILLISECONDS)
@State(Scope.Benchmark)
public class ReflectiveFieldAccessBenchmark {
    static {
        try {
            field = ReflectiveFieldAccessBenchmark.class.getDeclaredField("count");
        } catch (final ReflectiveOperationException e) {
            throw new ExceptionInInitializerError(e);
        }
    }

    private static final Field field;
    private static final VarHandle staticVarHandle = getVarHandle();
    private final VarHandle nonStaticVarHandle = getVarHandle();

    private final Number count = new AtomicInteger(Integer.MAX_VALUE);

    private static VarHandle getVarHandle() {
        try {
            return MethodHandles.lookup().unreflectVarHandle(field);
        } catch (final ReflectiveOperationException e) {
            throw new RuntimeException(e);
        }
    }

    @Benchmark
    public Object reflection() throws Exception {
        return field.get(this);
    }

    @Benchmark
    public Object staticVarHandle() throws Exception {
        return staticVarHandle.get(this);
    }

    @Benchmark
    public Object nonStaticVarHandle() throws Exception {
        return nonStaticVarHandle.get(this);
    }
}

测试输出 #

Benchmark                                                                         Mode   Cnt   Score    Error   Units
ReflectiveFieldAccessBenchmark.nonStaticVarHandle                                 avgt  1000   3.485 ±  0.005   ns/op
ReflectiveFieldAccessBenchmark.reflection                                         avgt  1000   2.027 ±  0.002   ns/op
ReflectiveFieldAccessBenchmark.staticVarHandle                                    avgt  1000   0.433 ±  0.002   ns/op

1. 全局缓存VarHandle #

将创建好的VarHandle以类全限定名+字段名为key，缓存到全局线程安全容器（如ConcurrentHashMap）中，避免重复初始化非静态VarHandle的开销。适配未知类场景的同时，复用VarHandle实例，触发JVM的优化。

示例代码：

private static final ConcurrentHashMap<String, VarHandle> VAR_HANDLE_CACHE = new ConcurrentHashMap<>();

public static VarHandle getCachedVarHandle(Class<?> clazz, String fieldName) throws ReflectiveOperationException {
    String cacheKey = clazz.getName() + "#" + fieldName;
    return VAR_HANDLE_CACHE.computeIfAbsent(cacheKey, key -> {
        Field field = clazz.getDeclaredField(fieldName);
        field.setAccessible(true); // 提前开启权限，避免重复校验
        return MethodHandles.lookup().unreflectVarHandle(field);
    });
}

2. 改用MethodHandle做字段读取 #

对于字段读取场景，非静态MethodHandle的性能损耗远低于非静态VarHandle，通常能和Field.get持平甚至略优。通过unreflectGetter获取字段的getter句柄，调用时传入实例即可。

示例代码：

// 获取字段的MethodHandle
Field field = targetClass.getDeclaredField(fieldName);
field.setAccessible(true);
MethodHandle getterHandle = MethodHandles.lookup().unreflectGetter(field);

// 读取字段值
Object fieldValue = getterHandle.invoke(targetInstance);

3. 提前处理字段权限 #

无论使用哪种反射替代方案，提前调用field.setAccessible(true)并缓存字段实例/句柄，能避免每次访问时的权限检查开销。这是反射场景性能优化的基础步骤，缺失会导致所有方案的性能大幅下降。

4. 复用句柄实例 #

JVM会对频繁调用的MethodHandle/VarHandle进行内联和调用点缓存优化，只要保证同一字段的句柄被重复使用，JVM就能逐步消除调用的额外开销。业务代码中要避免每次访问字段都重新创建句柄。

内容的提问来源于stack exchange，提问作者JackPGreen