MethodHandle性能测试

最新推荐文章于 2024-06-17 16:37:42 发布
最新推荐文章于 2024-06-17 16:37:42 发布
阅读量2.7k 收藏 1
点赞数
分类专栏： java 文章标签： JAVA MathodHandle
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kiyoki/article/details/50772870
版权
   JDK7以来新加入包java.lang.invoke，提供了一种新的动态确定目标方法的机制，称为MethodHandle.相对于java.lang.reflect内的Method,两者支持层面并不同。Reflection是java api层面的反射调用，而MethodHandle则是从jvm层面支持调用。Reflection是重量级的，而MethodHandle则是轻量级的。

   为了更清楚地了解其中区别，我编写了代码对其执行速度进行测试。分别在有预热和无预热的状态下，对Reflection机制在极多次调用下，jvm似乎有能力将其自动编译优化，速度比MethodHandle更快。而在调用较少的情况下，MethodHandle有其轻量级的优势。

   以下为测试代码：

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.reflect.Method;
import java.math.BigDecimal;

public class GoodestStatic {
	
	public static final int WARM_UP = 500_000; //预热次数
	public static int TEST_TIME= Integer.MAX_VALUE; //执行次数
	public volatile static boolean NEED_WARM_UP = false; //是否预热	
	
	public static final int good(int num){
		return num*5+1;
	}
	
	public static void main(String[] args) throws Throwable{
		if(args.length > 0){
			NEED_WARM_UP = "true".equalsIgnoreCase(args[0]);
		}
		
		if(args.length > 1){
			TEST_TIME = Integer.parseInt(args[1]);
		}
		
		System.out.println("WARM_UP ="+NEED_WARM_UP+",TEST_TIME="+TEST_TIME);
		
		test0(); //直接方法调用
		test1(); //Method反射调用
		test2(); //MethodHandle的invoke()调用
		test3(); //MethodHandle的invokeExact调用
	}

	private static void test0() throws Exception {		
		int sum = 0;
		if(NEED_WARM_UP)
		for(int i=0; i<WARM_UP;i++){
			sum += good(i);
		}
		
		long start = System.nanoTime();
		for(int i=0; i<TEST_TIME;i++){
			sum += good(i);
		}
		
		long end = System.nanoTime();
		System.out.println("Result ="+sum+",Test0 cost "+(end -start)+"ns.");	
		BigDecimal bd = new BigDecimal(end-start);
		bd = bd.divide(new BigDecimal(TEST_TIME),20,BigDecimal.ROUND_HALF_UP);
		System.out.println("per Time cost "+bd+" ns");
	}
	
	private static void test1() throws Exception {	
		Method m = GoodestStatic.class.getDeclaredMethod("good", int.class);
		
		int sum = 0;
		if(NEED_WARM_UP)
		for(int i=0; i<WARM_UP;i++){
			sum += (int)m.invoke(null, i);	
		}
		
		long start = System.nanoTime();
		for(int i=0; i<TEST_TIME;i++){
			sum += (int)m.invoke(null, i);			
		}
		long end = System.nanoTime();
		System.out.println("Result ="+sum+",Test1 cost "+(end -start)+"ns.");	
		BigDecimal bd = new BigDecimal(end-start);
		bd = bd.divide(new BigDecimal(TEST_TIME),20,BigDecimal.ROUND_HALF_UP);
		System.out.println("per Time cost "+bd+" ns");
	}
	
	private static void test2() throws Throwable {		
		MethodType mt = MethodType.methodType(int.class, int.class);
		MethodHandle m = MethodHandles.lookup().findStatic(GoodestStatic.class, "good", mt);
		
		int sum = 0;
		if(NEED_WARM_UP)
		for(int i=0; i<WARM_UP;i++){
			sum += (int)m.invoke(i);	
		}
		
		long start = System.nanoTime();
		for(int i=0; i<TEST_TIME;i++){
			sum += (int)m.invoke(i);		
		}
		long end = System.nanoTime();
		System.out.println("Result ="+sum+",Test2 cost "+(end -start)+"ns.");	
		BigDecimal bd = new BigDecimal(end-start);
        bd = bd.divide(new BigDecimal(TEST_TIME),20,BigDecimal.ROUND_HALF_UP);
		System.out.println("per Time cost "+bd+" ns");
	}
	
	private static void test3() throws Throwable {		
		MethodType mt = MethodType.methodType(int.class, int.class);
		MethodHandle m = MethodHandles.lookup().findStatic(GoodestStatic.class, "good", mt);
		
		int sum = 0;
		if(NEED_WARM_UP)
		for(int i=0; i<WARM_UP;i++){
			sum += (int)m.invokeExact(i);	
		}
				
		long start = System.nanoTime();
		for(int i=0; i<TEST_TIME;i++){
			sum += (int)m.invokeExact(i);		
		}
		long end = System.nanoTime();
		System.out.println("Result ="+sum+",Test3 cost "+(end -start)+"ns.");	
		BigDecimal bd = new BigDecimal(end-start);
		bd = bd.divide(new BigDecimal(TEST_TIME),20,BigDecimal.ROUND_HALF_UP);
		System.out.println("per Time cost "+bd+" ns");
	}
	
}

测试环境：

CPU:  Intel i5-6600K@4.5G

内存:  DDR3200 8Gx2 

OS:win7 64bit


先使用jvm1.7进行测试：

D:\Program Files\Java\jdk1.7.0_40\bin>java -version
java version "1.7.0_40"
Java(TM) SE Runtime Environment (build 1.7.0_40-b43)
Java HotSpot(TM) 64-Bit Server VM (build 24.0-b56, mixed mode)

D:\Program Files\Java\jdk1.7.0_40\bin>java GoodestStatic true 5000
WARM_UP =true,TEST_TIME=5000
Result =-2003482716,Test0 cost 1169ns.
per Time cost 0.23380000000000000000 ns
Result =-2003482716,Test1 cost 101112ns.
per Time cost 20.22240000000000000000 ns
Result =-2003482716,Test2 cost 392176ns.
per Time cost 78.43520000000000000000 ns
Result =-2003482716,Test3 cost 31269ns.
per Time cost 6.25380000000000000000 ns

D:\Program Files\Java\jdk1.7.0_40\bin>java GoodestStatic false 5000
WARM_UP =false,TEST_TIME=5000
Result =62492500,Test0 cost 98190ns.
per Time cost 19.63800000000000000000 ns
Result =62492500,Test1 cost 3388143ns.
per Time cost 677.62860000000000000000 ns
Result =62492500,Test2 cost 34774205ns.
per Time cost 6954.84100000000000000000 ns
Result =62492500,Test3 cost 644957ns.
per Time cost 128.99140000000000000000 ns

D:\Program Files\Java\jdk1.7.0_40\bin>java GoodestStatic true
WARM_UP =true,TEST_TIME=2147483647
Result =1155250260,Test0 cost 508026604ns.
per Time cost 0.23656832251537978766 ns
Result =1155250260,Test1 cost 20721040125ns.
per Time cost 9.64898622345597773020 ns
Result =1155250260,Test2 cost 154064924123ns.
per Time cost 71.74207092949285680870 ns
Result =1155250260,Test3 cost 10129340931ns.
per Time cost 4.71684193970488474691 ns

D:\Program Files\Java\jdk1.7.0_40\bin>java GoodestStatic false
WARM_UP =false,TEST_TIME=2147483647
Result =-1073741820,Test0 cost 515627571ns.
per Time cost 0.24010779859503162959 ns
Result =-1073741820,Test1 cost 7117198964ns.
per Time cost 3.31420403314484471136 ns
Result =-1073741820,Test2 cost 164902029058ns.
per Time cost 76.78849116656393332713 ns
Result =-1073741820,Test3 cost 8496807506ns.
per Time cost 3.95663432309247288997 ns


D:\Program Files\Java\jdk1.7.0_40\bin>java GoodestStatic true 5000 
WARM_UP =true,TEST_TIME=5000
Result =-2003482716,Test0 cost 1169ns.
per Time cost 0.23380000000000000000 ns
Result =-2003482716,Test1 cost 120984ns.
per Time cost 24.19680000000000000000 ns
Result =-2003482716,Test2 cost 389546ns.
per Time cost 77.90920000000000000000 ns
Result =-2003482716,Test3 cost 34191ns.
per Time cost 6.83820000000000000000 ns

D:\Program Files\Java\jdk1.7.0_40\bin>java GoodestStatic false 5000 
WARM_UP =false,TEST_TIME=5000
Result =62492500,Test0 cost 96144ns.
per Time cost 19.22880000000000000000 ns
Result =62492500,Test1 cost 3296090ns.
per Time cost 659.21800000000000000000 ns
Result =62492500,Test2 cost 35162582ns.
per Time cost 7032.51640000000000000000 ns
Result =62492500,Test3 cost 609304ns.
per Time cost 121.86080000000000000000 ns

D:\Program Files\Java\jdk1.7.0_40\bin>java GoodestStatic true  
WARM_UP =true,TEST_TIME=2147483647
Result =1155250260,Test0 cost 508109013ns.
per Time cost 0.23660669719642340075 ns
Result =1155250260,Test1 cost 20455020598ns.
per Time cost 9.52511122800647803955 ns
Result =1155250260,Test2 cost 163458260579ns.
per Time cost 76.11618407774538922950 ns
Result =1155250260,Test3 cost 10206268212ns.
per Time cost 4.75266399642110988331 ns

D:\Program Files\Java\jdk1.7.0_40\bin>java GoodestStatic false  
WARM_UP =false,TEST_TIME=2147483647
Result =-1073741820,Test0 cost 516316363ns.
per Time cost 0.24042854236458825989 ns
Result =-1073741820,Test1 cost 7059888957ns.
per Time cost 3.28751698149718203652 ns
Result =-1073741820,Test2 cost 171611770599ns.
per Time cost 79.91295805150315074786 ns
Result =-1073741820,Test3 cost 8514055068ns.
per Time cost 3.96466584502005290474 ns

调用次数在测试中选用 小测试次数5000 和 大测试次数2147483647。从两次测试中可以看到，小次数调用的情况下，MethodHandle的invokeExact()方法确实具有优势。而在大次数调用下，Method的invokes执行速度变现怪异，在有预热的状况下执行速度反而处于劣势，推测因循环次数不用触发jit重编译引起，未能使用debug版测试环境验证推测。在没有预热的情况下，Method的invoke执行速度喜人，快于MethodHandle的invokeExact(),而MethodHandle的invoke()方法在jvm1.7中表现得非常差，无论小次数调用抑或大次数调用，执行速度都无法与其他两者相比。


再使用jvm1.8进行测试:

D:\Program Files\Java\jdk1.8.0_25\bin>java -version
java version "1.8.0_25"
Java(TM) SE Runtime Environment (build 1.8.0_25-b18)
Java HotSpot(TM) 64-Bit Server VM (build 25.25-b02, mixed mode)

D:\Program Files\Java\jdk1.8.0_25\bin>java GoodestStatic true 5000
WARM_UP =true,TEST_TIME=5000
Result =-2003482716,Test0 cost 12566ns.
per Time cost 2.51320000000000000000 ns
Result =-2003482716,Test1 cost 98775ns.
per Time cost 19.75500000000000000000 ns
Result =-2003482716,Test2 cost 31561ns.
per Time cost 6.31220000000000000000 ns
Result =-2003482716,Test3 cost 53186ns.
per Time cost 10.63720000000000000000 ns

D:\Program Files\Java\jdk1.8.0_25\bin>java GoodestStatic false 5000
WARM_UP =false,TEST_TIME=5000
Result =62492500,Test0 cost 100528ns.
per Time cost 20.10560000000000000000 ns
Result =62492500,Test1 cost 2374097ns.
per Time cost 474.81940000000000000000 ns
Result =62492500,Test2 cost 1252508ns.
per Time cost 250.50160000000000000000 ns
Result =62492500,Test3 cost 432796ns.
per Time cost 86.55920000000000000000 ns

D:\Program Files\Java\jdk1.8.0_25\bin>java GoodestStatic true
WARM_UP =true,TEST_TIME=2147483647
Result =1155250260,Test0 cost 513498658ns.
per Time cost 0.23911644622642381407 ns
Result =1155250260,Test1 cost 20213309554ns.
per Time cost 9.41255575204852770644 ns
Result =1155250260,Test2 cost 10503014524ns.
per Time cost 4.89084726613520051638 ns
Result =1155250260,Test3 cost 8798333281ns.
per Time cost 4.09704320370081961327 ns

D:\Program Files\Java\jdk1.8.0_25\bin>java GoodestStatic false
WARM_UP =false,TEST_TIME=2147483647
Result =-1073741820,Test0 cost 513264286ns.
per Time cost 0.23900730825914410328 ns
Result =-1073741820,Test1 cost 6697535282ns.
per Time cost 3.11878290265741893214 ns
Result =-1073741820,Test2 cost 8808774164ns.
per Time cost 4.10190511872149310947 ns
Result =-1073741820,Test3 cost 8799512440ns.
per Time cost 4.09759229239895580914 ns


D:\Program Files\Java\jdk1.8.0_25\bin>java GoodestStatic true 5000 
WARM_UP =true,TEST_TIME=5000
Result =-2003482716,Test0 cost 12273ns.
per Time cost 2.45460000000000000000 ns
Result =-2003482716,Test1 cost 100528ns.
per Time cost 20.10560000000000000000 ns
Result =-2003482716,Test2 cost 33315ns.
per Time cost 6.66300000000000000000 ns
Result =-2003482716,Test3 cost 53479ns.
per Time cost 10.69580000000000000000 ns

D:\Program Files\Java\jdk1.8.0_25\bin>java GoodestStatic false 5000 
WARM_UP =false,TEST_TIME=5000
Result =62492500,Test0 cost 109003ns.
per Time cost 21.80060000000000000000 ns
Result =62492500,Test1 cost 2249897ns.
per Time cost 449.97940000000000000000 ns
Result =62492500,Test2 cost 1214518ns.
per Time cost 242.90360000000000000000 ns
Result =62492500,Test3 cost 413802ns.
per Time cost 82.76040000000000000000 ns

D:\Program Files\Java\jdk1.8.0_25\bin>java GoodestStatic true  
WARM_UP =true,TEST_TIME=2147483647
Result =1155250260,Test0 cost 515921264ns.
per Time cost 0.24024456005554858598 ns
Result =1155250260,Test1 cost 20449255728ns.
per Time cost 9.52242675121986621582 ns
Result =1155250260,Test2 cost 10516892353ns.
per Time cost 4.89730963385538646665 ns
Result =1155250260,Test3 cost 10538898336ns.
per Time cost 4.90755696823241047945 ns

D:\Program Files\Java\jdk1.8.0_25\bin>java GoodestStatic false  
WARM_UP =false,TEST_TIME=2147483647
Result =-1073741820,Test0 cost 516242136ns.
per Time cost 0.24039397772419917291 ns
Result =-1073741820,Test1 cost 7451620181ns.
per Time cost 3.46993104762860156951 ns
Result =-1073741820,Test2 cost 8833791018ns.
per Time cost 4.11355449916494754104 ns
Result =-1073741820,Test3 cost 8817718231ns.
per Time cost 4.10607002447641921438 ns

从1.8的测试中可以看出，无论是Reflection还是MethodHandle，两者的速度都有了提升 Method.invoke()与MethodHandle.invokeExact()的执行速度依然表现出与1.7环境下的差距。而MethodHandle的invoke()在1.8中得到了极大提升，速度逼近MethodHandle.invokeExact()。

   

        从测试中可以看出，只有在小次数调用下MethodHandle才会有优势。但小次数调用的代码通常不注重什么效率，这就使人觉得其地位尴尬了。可见，Reflection的Method反射机制仍然是我们的反射首选。



附CentOS下测试,i3-4160+8G ram:

[seamas@localhost ~]$ java -version
java version "1.7.0_75"
OpenJDK Runtime Environment (rhel-2.5.4.2.el7_0-x86_64 u75-b13)
OpenJDK 64-Bit Server VM (build 24.75-b04, mixed mode)
[seamas@localhost ~]$ java GoodestStatic true 5000
WARM_UP =true,TEST_TIME=5000
Result =-2003482716,Test0 cost 2571ns.
per Time cost 0.51420000000000000000 ns
Result =-2003482716,Test1 cost 97881ns.
per Time cost 19.57620000000000000000 ns
Result =-2003482716,Test2 cost 556485ns.
per Time cost 111.29700000000000000000 ns
Result =-2003482716,Test3 cost 51370ns.
per Time cost 10.27400000000000000000 ns
[seamas@localhost ~]$ java GoodestStatic false  5000
WARM_UP =false,TEST_TIME=5000
Result =62492500,Test0 cost 677493ns.
per Time cost 135.49860000000000000000 ns
Result =62492500,Test1 cost 10841897ns.
per Time cost 2168.37940000000000000000 ns
Result =62492500,Test2 cost 60150515ns.
per Time cost 12030.10300000000000000000 ns
Result =62492500,Test3 cost 2022143ns.
per Time cost 404.42860000000000000000 ns
[seamas@localhost ~]$ java GoodestStatic true
WARM_UP =true,TEST_TIME=2147483647
Result =1155250260,Test0 cost 648155339ns.
per Time cost 0.30182084967467042137 ns
Result =1155250260,Test1 cost 29811490738ns.
per Time cost 13.88205716008416244764 ns
Result =1155250260,Test2 cost 227465171362ns.
per Time cost 105.92172456342807252120 ns
Result =1155250260,Test3 cost 14363211021ns.
per Time cost 6.68839133702609284642 ns
[seamas@localhost ~]$ java GoodestStatic false
WARM_UP =false,TEST_TIME=2147483647
Result =-1073741820,Test0 cost 648307322ns.
per Time cost 0.30189162227413226956 ns
Result =-1073741820,Test1 cost 10100713630ns.
per Time cost 4.70351131386287105915 ns
Result =-1073741820,Test2 cost 232768978072ns.
per Time cost 108.39150202478817758373 ns
Result =-1073741820,Test3 cost 12097328362ns.
per Time cost 5.63325750065653468513 ns









kiyoki
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java methodhandler_MethodHandle VS Method, Java反射及MethodHandle性能测试
weixin_36389468的博客
02-24 279
从结果来看, Oracle的Java新特性MethodHandle还有很多要优化的地方import java.lang.invoke.MethodHandle;import java.lang.invoke.MethodHandles;import java.lang.invoke.MethodType;import java.lang.reflect.Method;public class In...
MethodHandle与反射Method区别，invokedynamic指令
yushui的笔记本
08-27 6650
MethodHandle与反射Method区别MethodHandle的使用方法和效果上与Reflection都有众多相似之处。不过，它们也有以下这些区别： Reflection和MethodHandle机制本质上都是在模拟方法调用，但是Reflection是在模拟Java代码层次的方法调用，而MethodHandle是在模拟字节码层次的方法调用。在MethodHandles.Lookup上的三个方
Java里的MethodHandles是什么? 和反射有什么区别?
AmazDreamer的博客
11-27 582
然而，考虑到性能并不是任务的唯一适用性度量，我们还必须考虑到，由于缺乏成员类枚举、可访问性标志检查等机制，MethodHandles API更难使用。特别是，查找工厂提供了一组方法，使我们能够在考虑方法范围的情况下以适当的方式找到方法句柄。当我们想要创建方法句柄时，要做的第一件事是检索查找Lookup，即负责为查找类可见的方法、构造函数和字段创建方法句柄的工厂对象。在本文中，我们将探讨一个重要的API，它是在Java7中引入的，并在以后的jdk版本中得到了增强，即。
Java MethodHandle 的使用
最新发布
u011345634的博客
06-17 2090
Java的MethodHandle提供了一种高效、轻量级且类型安全的方法来动态调用Java方法，比反射性能更好
java methodhandle_java – MethodHandle性能
weixin_31937605的博客
03-06 160
我写了一个基准测试来测试java.lang.invoke.MethodHandle，java.lang.reflect.Method和方法的直接调用的性能。我看到MethodHandle.invoke()性能几乎和直接调用相同。但是我的测试结果显示另一个：MethodHandle调用比反射慢约三倍。我的问题是什么？可能这是JIT优化的结果吗？public class Main {public st...
MethodHandle基本用法
06-06 1608
package org.suych; import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; public class MethodHandleTest { private String name; // 构造...
MethodHandle VS Method, Java反射及MethodHandle性能测试
David_Ding的专栏
01-05 4243
从结果来看, Oracle的Java新特性MethodHandle还有很多要优化的地方 import java.lang.invoke.MethodHandle; import java.lang.invoke.MethodHandles; import java.lang.invoke.MethodType; import java.lang.reflect.Method; publ
答复: 通过代码简单介绍JDK 7的MethodHandle，并与.NET的委托对比（二）
05-25
至于压缩包中的`TestMethodSameName.class`文件，这可能是一个简单的Java测试类，用于演示或测试MethodHandle如何处理相同方法名的情况。在Java中，如果不同包或类中有同名方法，MethodHandle可以提供精确的方法调用...
java-handles-kata:Java反射和不安全的替代方法-MethodHandle和VarHandle API-修复代码卡塔中损坏的测试
05-23
2. 性能瓶颈：如果反射调用成为性能瓶颈，应考虑使用MethodHandle替换传统的反射API。 3. 线程安全性：检查是否需要使用VarHandle来确保字段访问的原子性和可见性，特别是在多线程环境下。 4. 安全问题：避免使用`...
Java源码反射-mgJavaNote:关于纯java语言的的各种测试与实验并发(很多)源码分析,nio,aio,网络编程GC,反射与动态码,
05-19
`java.lang.invoke`包提供了`MethodHandle`和`LambdaMetafactory`等工具，使得这种操作更加高效和安全。 并发是Java开发中的重要主题，Java提供了一套完整的并发控制机制，包括线程、锁、并发集合等。在Java源码中...
Java 动态代理
04-21
- 测试：在测试中，可以使用代理来模拟或替换某些复杂组件，简化测试逻辑。 5. **优缺点**： - 优点：代码解耦，提高了灵活性和可扩展性；无需修改原有代码即可增加新功能。 - 缺点：性能开销，特别是在高并发...
CMov:Cmov 项目存储库
06-03
同时，项目中的测试用例可以帮助我们理解这些优化如何在实际场景中发挥作用，并提供了一个评估性能提升的标准。 总的来说，CMov项目为Java开发者提供了一个学习和实践代码优化的平台，特别是对于理解和实现处理器...
java 各种方法反射性能对比（原生/Introspector/MethodHandles/MethodAccess)
dyj025的博客
03-02 749
直接上代码： package com.example.demo; import com.esotericsoftware.reflectasm.MethodAccess; import lombok.Data; import lombok.Getter; import org.junit.Test; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringB
Java通过反射新增方法_JDK1.7新增的MethodHandle方法与反射调用的例子
weixin_42298817的博客
02-25 562
java中通过类调用类的方法之前一直使用反射的机制去做，但是jdk1.7中增加了对动态语言的支持，增加了MethodHandle方法MethodHandle的Demo新建一个类ClassA，方法printlnpublic class ClassA {public void println(String s) {System.out.println(s);}}method handle方法使用pri...
MethodHandler
weixin_33812433的博客
09-29 689
2019独角兽企业重金招聘Python工程师标准>>> ...
MethodHandle
weixin_34043301的博客
01-11 82
为什么80%的码农都做不了架构师？>>> ...
JVM角度看方法调用-反射篇
yangxiaofei_java的博客
05-26 466
文章目录一、反射调用的原理1.1获取MethodAccessor1.2 native版本MethodAccessor的实现1.3 java版本的MethodAccessor的实现二、反射调用优2.1、为什么反射调用性能低2.2、反射调用性能测试和优化(一)、直接调用(二)、反射调用(三)、反射调用优化版本1(四)、反射调用优化版本2(五)、反射调用优化版本3(六)、MethodHandle的黑魔法(七)、java版本超多态虚方法无法内联问题(八)、总结 JVM角度看方法调用系列文章： 1.JVM角度看方法
Java7 新特性：MethodHandler，MethodHandles，MethodHandles.Lookup用法详解
qq_37718687的博客
04-24 3149
相关类介绍 MethodType类 MethodType是不可变类，提供了对方法所有输入参数和输出参数的描述。创建MethodType类实例的方法是调用静态方法MethodType.methodType()，该方法的第一个参数是方法的返回类型，之后的所有参数都是方法的参数类型。MethodType类通过静态方法MethodType.methodType创建。 // 创建一个MethodType类型对象，其返回值是String，第一个参数类型是char，第二个参数类型是char mt = MethodType
java反射的优化_请问Java反射的性能为什么比直接调用慢一个数量级左右？
weixin_39806388的博客
02-12 414
Method.invoke()本身要用数组包装参数；而且每次调用都必须检查方法的可见性(在Method.invoke()里)，也必须检查每个实际参数与形式参数的类型匹配性(在NativeMethodAccessorImpl.invoke0()里或者生成的Java版MethodAccessor.invoke()里)；而且Method.invoke()就像是个独木桥一样，各处的反射调用都要挤过去，在调...
MethodHandle.invokeExact are only supported starting with Android O (--min-api 26)
07-13
对于在 Android O（API级别26）及更高版本上使用 MethodHandle.invokeExact 方法，您需要将 minSdkVersion 设置为 26 或更高版本。这是因为 MethodHandle.invokeExact 是在 Android O 平台上添加的功能。如果您的应用程序的 minSdkVersion 小于 26，则无法直接使用该方法。 如果您的应用程序需要在较低版本的 Android 上运行，并且想要使用 MethodHandle.invokeExact 方法，有两个解决方案： 1. 使用较低版本的替代方法：您可以使用 MethodHandle.invoke 方法作为 MethodHandle.invokeExact 的替代方法。虽然它们可能在性能或其他方面有所不同，但可以实现类似的功能。请注意，这可能需要对代码进行适当的修改。 2. 使用条件语句进行版本检查：如果您的应用程序需要在不同版本的 Android 上运行，并且您希望根据平台版本选择使用不同的方法，则可以使用条件语句进行版本检查。例如，您可以使用 Build.VERSION.SDK_INT 检查设备的 API 级别，并在满足特定条件时选择使用 MethodHandle.invokeExact 方法。 这两种方法都有其优缺点，具体取决于您的应用程序需求和兼容性要求。请根据您的具体情况选择适合您的解决方案。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值