反射调用的性能对比

反射虽然强大，但存在性能的不足，使用反射基本上是一种解释操作，您可以告诉JVM您希望做什么并且它满足您的要求。曾经看过一本书举例说调用同一个方法，使用反射来动态实现比直接在源代码中编写的方式大概慢一到两个数量级。或许方法比较快些，但经过测试发现字段更慢。

测试Demo如下：

1. package net.oseye;
2. import java.lang.reflect.Field;
3.  
4. public class ReflectTest {
5. //直接调用
6. public static int numAdd(int loops){
7. int val=0;
8. long startTime=0;
9. for(int i=0;i<loops;i++){
10. if(i==0){startTime=System.nanoTime();}
11. val+=i;
12. }
13. long totalTime=System.nanoTime()-startTime;
14. System.out.println("直接调用总的纳秒时间：\t\t"+totalTime);
15. return val;
16. }
17. //引用调用字段
18. public static int numAddReference(int loops){
19. User user=new User();
20. long startTime=0;
21. for(int i=0;i<loops;i++){
22. if(i==0){startTime=System.nanoTime();}
23. user.num+=i;
24. }
25. long totalTime=System.nanoTime()-startTime;
26. System.out.println("引用调用字段总的纳秒时间：\t"+totalTime);
27. return user.num;
28. }
29. //反射调用字段
30. public static int numAddReflection(int loops) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException{
31. User user=new User();
32. long startTime=0;
33. for(int i=0;i<loops;i++){
34. if(i==0){startTime=System.nanoTime();}
35. Class<?> cUser=user.getClass();
36. Field field=cUser.getField("num");
37. field.set(user, field.getInt(user)+i);
38. }
39. long totalTime=System.nanoTime()-startTime;
40. System.out.println("反射调用字段总的纳秒时间：\t"+totalTime);
41. return user.num;
42. }
44. public static void main(String[] args) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException{
45. int loops=1000000;
46. numAdd(loops);
47. numAddReference(loops);
48. numAddReflection(loops);
49. }
50. }
51. class User{
52. public int num;
53. }

输出：

1. 直接调用总的纳秒时间： 4784726
2. 引用调用字段总的纳秒时间： 26341772
3. 反射调用字段总的纳秒时间： 2707670627

测试100万次，除掉第一次的时间，可以看出反射用的时间是引用的100倍，是直接调用的500多倍。当然根据测试的次数不同，机器的配置不同，结果稍有不同