一.总述
JDK1.7为间接调用方法提供了MethodHandle类，即方法句柄。是对之前JDK1.7之前反射性能不佳的优化手段之一 代码案例如下
jspackage
代码解读
复制代码
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import org.junit.jupiter.api.Test;
public class TestMethodHandlesLookup {
private static void printData () {
System.out.println("print data method.");
}
@Test
public void testMethodData() throws Throwable {
/*
* 使用反射提前获取类型
*/
MethodHandles.Lookup methodHandles=MethodHandles.lookup().in(TestMethodHandlesLookup.class);
MethodType type= MethodType.methodType(void.class);
MethodHandle method = methodHandles.findStatic(TestMethodHandlesLookup.class, "printData", type);
method.invokeExact();
}
}
用MethodHandle调用方法的流程为：
- 创建MethodType,获取指定方法的签名
- 在Lookup中查找MethodType的方法句柄MethodHandle
- 传入方法参数通过MethodHandle调用方法
创建MethodType
MethodType表示一个方法类型的对象，每个MethodHandle都有一个MethodType实例，MethodType用来指明方法的返回类型和参数类型。其有多个工厂方法的重载``
jsstatic
代码解读
复制代码
static MethodType methodType(Class<?> rtype, Class<?> ptype0)
static MethodType methodType(Class<?> rtype, Class<?>[] ptypes)
static MethodType methodType(Class<?> rtype, Class<?> ptype0, Class<?>... ptypes)
static MethodType methodType(Class<?> rtype, List<Class<?>> ptypes)
static MethodType methodType(Class<?> rtype, MethodType ptypes)
rtType 表示方法的返回类型，ptypes 表示方法请求参数
创建Lookup
MethodHandle.Lookup可以通过相应的findxxx方法得到相应的MethodHandle，相当于MethodHandle的工厂方法。查找对象上的工厂方法对应于方法、构造函数和字段的所有主要用例。下面是官方API文档对findxxx的说明，这些工厂方法和结果方法处理的行为之间的对应关系: 
findStatic相当于得到的是一个static方法的句柄，findVirtual找的是普通方法 findSpecial查找私有方法、超类的方法或隐藏的方法（在子类中被重写的方法）
第一种方式 使用工厂创建LookUp
js
代码解读
复制代码
MethodHandles.Lookup methodHandles=MethodHandles.lookup();
第二种方式 使用Unsafe来获取LookUp，如果考虑性能个人推荐这种方式实现。 如果权限报错，请添参数启动 --add-opens java.base/sun.misc=ALL-UNNAMED --add-opens java.base/java.lang.reflect=ALL-UNNAMED --add-opens java.base/java.lang.invoke=ALL-UNNAMED
js
代码解读
复制代码
Unsafe unsafe=null;
Field unsafefiled = Unsafe.class.getDeclaredField("theUnsafe");
unsafefiled.setAccessible(true);
unsafe= (Unsafe) unsafefiled.get(null);
Lookup lookup=null;
try {
Field sd = Lookup.class.getDeclaredField("IMPL_LOOKUP");
sd.setAccessible(true);
long offeset = unsafe.staticFieldOffset(sd);
lookup = (Lookup) unsafe.getObject(Lookup.class, offeset);
System.out.println("避免反射来创建lookup失败**");**
} catch (Exception e) {
lookup= MethodHandles.lookup();
}
第三种方式， 可以通过反射构造函数来实现
js
代码解读
复制代码
public static MethodHandles.Lookup getLookupByReflection(Class<?> cls) {
try {
Constructor<Lookup> constructor =
MethodHandles.Lookup.class.getDeclaredConstructor(Class.class, int.class);
constructor.setAccessible(true);
return constructor.newInstance( cls, -1 );// 相当于lookup.in(Class);
} catch (Exception e) {
return null
}
创建MethodHandle方法句柄
- 使用
Lookup对象的findStatic(),findVirtual(),findSpecial(),findConstructor()等方法来查找并获取目标方法的MethodHandle对象 - 如果MethodHandle指向的是实例方法，可以使用
MethodHandle对象的bindTo()方法将其绑定到目标实例上 - 使用MethodHandle对象的
invoke()、invokeExact()、invokeWithArguments()等方法来调用目标方法
invoke()：提供类型适配的灵活调用，允许在运行时转换参数类型。invokeExact()：提供严格的类型检查，要求参数类型与目标方法完全匹配。invokeWithArguments()：允许使用列表作为参数进行调用，提供了更大的灵活
与反射的区别
性能：MethodHandle通常比反射更快，因为它绕过了许多反射的额外开销。
类型安全：MethodHandle在编译时会进行类型检查，而反射在运行时进行类型检查，可能导致ClassCastException等异常。
用法：反射需要先获取Method对象，而MethodHandle直接对方法进行引用
总结：但是实际使用起来性能并没有明显多大提升，但是我们可以利用callSite来提升性能
普通案例：
js
代码解读
复制代码
@Test
public void testMethodData() throws Throwable {
/*
* 使用反射提前获取类型
*/
MethodHandles.Lookup methodHandles=MethodHandles.lookup().in(LooKUpTest.class);
MethodType type= MethodType.methodType(void.class);
MethodHandle method = methodHandles.findStatic(LooKUpTest.class, "printData", type);
long start=System.currentTimeMillis();
for (int i = 0; i <100000; i++) {
method.invokeExact();
}
System.out.println(System.currentTimeMillis()-start);
}
优化案例：ConstantCallSite是java.lang.invoke包中的一个类，它是CallSite的一个实现，用于表示一个调用点，该调用点总是返回一个常量值。以下是一个简单的使用ConstantCallSite的例子CallSite实现类的简要概述：
- ConstantCallSite:
ConstantCallSite表示一个调用点，该调用点的目标方法句柄永远不会改变。- 它通常用于优化已知永远不会改变的目标方法的调用。
- MutableCallSite:
MutableCallSite允许在运行时改变其目标方法句柄。- 它适用于需要动态改变方法行为的场景。
- VolatileCallSite:
VolatileCallSite是MutableCallSite的一个子类，其目标方法句柄的所有更新都是原子的，并且每次调用时都会重新读取目标方法句柄。- 它适用于多线程环境中，其中目标方法句柄可能会被多个线程并发修改。
js
代码解读
复制代码
@Test
public void testMethodDataConstant() throws Throwable {
MethodHandles.Lookup methodHandles=MethodHandles.lookup().in(LooKUpTest.class);
MethodType type= MethodType.methodType(void.class);
MethodHandle method = methodHandles.findStatic(LooKUpTest.class, "printData", type);
ConstantCallSite callSite=new ConstantCallSite(method);
long start=System.currentTimeMillis();
for (int i = 0; i <100000; i++) {
callSite.dynamicInvoker();
}
System.out.println(System.currentTimeMillis()-start);
}
案例测试验证 性能比较
js
代码解读
复制代码
@Test
public void testData() throws Throwable {
MethodHandles.Lookup lookup = MethodHandles.lookup();
long startTime = System.nanoTime();
MethodType tyep = MethodType.methodType(void.class);
// 不使用in方法查找
MethodHandle mh = lookup.findStatic(LookupPerformanceTest.class, "dummyMethod", tyep);
for (int i = 0; i < 1000000; i++) {
// Method method = LookupPerformanceTest.class.getMethod("dummyMethod");
// MethodHandle mh = lookup.unreflect(method);
mh.invokeExact();
}
long endTime = System.nanoTime();
System.out.println("LookUp不使用in方法耗时: " + TimeUnit.NANOSECONDS.toMillis(endTime - startTime) + " ms");
startTime = System.nanoTime();
ConstantCallSite callSite=new ConstantCallSite(mh);
for (int i = 0; i < 1000000; i++) {
callSite.dynamicInvoker();
}
endTime = System.nanoTime();
System.out.println("使用ConstantCallSite方法耗时: " + TimeUnit.NANOSECONDS.toMillis(endTime - startTime) + " ms");
startTime = System.nanoTime();
lookup.in(LookupPerformanceTest.class); //绑定查找类型
// 使用in方法查找
MethodHandle mh1 = lookup.findStatic(LookupPerformanceTest.class, "dummyMethod", tyep);
for (int i = 0; i < 1000000; i++) {
// Method method = LookupPerformanceTest.class.getMethod("dummyMethod");
mh1.invokeExact();
}
endTime = System.nanoTime();
System.out.println("Lookup使用in方法耗时: " + TimeUnit.NANOSECONDS.toMillis(endTime - startTime) + " ms");
}
为什么ConstantCallSite 性能能够提升这么多。ConstantCallSite 是一种特殊的 CallSite，它被设计为在运行时不会改变其目标方法句柄。这种实现采取的优化手段包括：
- 不变性保证：由于
ConstantCallSite的目标方法句柄在创建后不会改变，JVM 可以应用特定的优化策略。例如，它可以假定调用该CallSite的代码总是执行相同的操作，因此可以省去查找和更新目标方法句柄的开销。 - 内联优化：JVM 编译器可以将
ConstantCallSite的调用内联到调用者的代码中。这意味着调用CallSite的代码可以直接转换为目标方法句柄的代码，从而避免了调用开销。 - 缓存目标方法：因为
ConstantCallSite的目标方法句柄是固定的，JVM 可以将其缓存在方法调用链中，从而在每次调用时直接跳转到目标方法，而不是再次解析方法句柄。 - 减少安全检查：由于目标方法句柄是固定的，JVM 可能会减少或省略一些安全检查，例如，检查是否有权限调用特定的方法。
先配置添加打印JIT日志参数
- -XX:+PrintCompilation
- -XX:+UnlockDiagnosticVMOptions
- -XX:+PrintInlining
js
代码解读
复制代码
@Test
public void optionData() throws NoSuchMethodException, IllegalAccessException {
MethodHandles.Lookup lookup = MethodHandles.lookup();
MethodType tyep = MethodType.methodType(void.class);
// 不使用in方法查找
MethodHandle mh = lookup.findStatic(LookupPerformanceTest.class, "dummyMethod", tyep);
ConstantCallSite callSite=new ConstantCallSite(mh);
callSite.dynamicInvoker();
}
