JVM是如何实现Java反射的?

字数 806阅读 370

Java的反射应用场景非常多,例如IDE在做联想时,Spring的IoC容器等等。
通过反射,我们可以做一些平时做不到的事儿,例如调用其他对象的私有方法,获取其任意属性,总之在反射面前,任何Java对象都毫无隐私可言。

反射调用的实现

我们首先来观察一下Method.invoke()方法。相关源代码在java.lang.reflect包下的Method类中。

public Object invoke(Object obj, Object... args)
        throws IllegalAccessException, IllegalArgumentException,
           InvocationTargetException
    {
        // 权限检查,忽略 ...
        if (!override) {
            if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                Class<?> caller = Reflection.getCallerClass();
                checkAccess(caller, clazz, obj, modifiers);
            }
        }
        // 看这里 ...
        MethodAccessor ma = methodAccessor; // read volatile
        if (ma == null) {
            ma = acquireMethodAccessor();
        }
        return ma.invoke(obj, args);
    }

可以看到,这里讲方法的调用,委派给了MethodAccessor类型的ma对象来处理。它是一个接口,有两个实现类。一个委派实现(DelegatingMethodAccessorImpl),一个本地实现(NativeMethodAccessorImpl)。每一个Method实例的第一次调用,都会使用委派实现!,但是委派实现最终委派的实现确实本地实现。下面通过里一个例子观察一下:

/**
 * @author gzd
 * @date 2018-09-09 下午5:59
 * @desc 观察本地实现和委派实现
 */
public class HowReflect {
    public static void targetMethod(int i) {
        // 打印调用栈
        new Exception("version " + i)
                .printStackTrace();
    }

    public static void main(String[] args) throws Exception {
        Class<?> howReflect = Class.forName("com.ynwa.jvm.HowReflect");
        Method method = howReflect.getMethod("targetMethod", int.class);
        // 执行方法
        method.invoke(null, 0);
    }
}

上面的代码运行结果为:

java.lang.Exception: 版本 0
    at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:13)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    // 4 委派实现又委派给了本地实现
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    // 3 生成委派实现
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    // 2 反射调用方法
    at java.lang.reflect.Method.invoke(Method.java:498)
    // 1 执行main方法
    at com.ynwa.jvm.HowReflect.main(HowReflect.java:21)

上面在结果打印的调用栈中,注释的第3步个第4步,可以看到先用的委派实现,委派实现又委派了本地实现!

那么问题来了!既然最终要用本地实现,那么为什么中间要加一层委派实现?,那么继续向下看。

其实这是因为除了以上两种以外,还有一种动态实现,而所谓的委派实现,只不过是为了能够在本地实现动态实现之间做切换。动态实现是一种字节码技术。

但是如果只调用一次的话,本地实现要比动态实现块一点儿,这是因为动态实现操作字节码要慢一些。JVM会认为你每次只会很少的进行方法调用(或者说只调用一次),所以它设定了一个阀值:16,如果调用15此以上,也就是说第17次开始,使用动态实现。使用本地实现的时候,因为要经过Java -> c++ -> Java的过程。第17次开始,JVM会利用已经生成的字节码来进行方法调用,所以这无疑就会增速很多!

下面来循环20次上面的代码,直观的看一下,这个过程:

/**
 * @author gzd
 * @date 2018-09-09 下午5:59
 * @desc 观察本地实现和委派实现
 */
public class HowReflect {
    public static void targetMethod(int i) {
        // 打印调用栈
        new Exception("版本 " + i)
                .printStackTrace();
    }

    public static void main(String[] args) throws Exception {
        Class<?> howReflect = Class.forName("com.ynwa.jvm.HowReflect");
        Method method = howReflect.getMethod("targetMethod", int.class);
        for (int i = 0; i < 20; i++) {
            // 执行方法
            method.invoke(null, i);
        }
    }
}

下面是执行结果:

java.lang.Exception: 版本 0
    at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:14)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.ynwa.jvm.HowReflect.main(HowReflect.java:23)
java.lang.Exception: 版本 1
    at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:14)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.ynwa.jvm.HowReflect.main(HowReflect.java:23)
    
    // 省略 2 -14 次 ... ... ...    

java.lang.Exception: 版本 15
    at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:14)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    // 0 -15 次还是使用的本地实现
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.ynwa.jvm.HowReflect.main(HowReflect.java:23)

java.lang.Exception: 版本 16
    at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:14)
    // 开始使用动态实现 !
    at sun.reflect.GeneratedMethodAccessor1.invoke(Unknown Source)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.ynwa.jvm.HowReflect.main(HowReflect.java:23)
java.lang.Exception: 版本 17
    at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:14)
    at sun.reflect.GeneratedMethodAccessor1.invoke(Unknown Source)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.ynwa.jvm.HowReflect.main(HowReflect.java:23)
java.lang.Exception: 版本 18
    at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:14)
    at sun.reflect.GeneratedMethodAccessor1.invoke(Unknown Source)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.ynwa.jvm.HowReflect.main(HowReflect.java:23)
java.lang.Exception: 版本 19
    at com.ynwa.jvm.HowReflect.targetMethod(HowReflect.java:14)
    at sun.reflect.GeneratedMethodAccessor1.invoke(Unknown Source)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:498)
    at com.ynwa.jvm.HowReflect.main(HowReflect.java:23)

从结果中可以看到,"版本 17" 开始,使用了动态实现。

反射调用的开销

刚才的代码中,Class.forName会调用本地方法,getMethod会遍历所有的共有方法,如果找不到则会去父类找,这些操作都比较费时。如果将上面的代码改造一下,运行一亿次的话,我的电脑结果为550ms。而直接调用只需要5ms。可以看出差距非常大,不过实验比较简陋,比如其他进程的影响,没考虑方法内联,还有Interger的数据缓存等等。
下面的改造后的局部代码:

public static void targetMethod(int i) {
        // 打印调用栈
// new Exception("版本 " + i)
// .printStackTrace();
    }
    public static void main(String[] args) throws Exception {
        Class<?> howReflect = Class.forName("com.ynwa.jvm.HowReflect");
        Method method = howReflect.getMethod("targetMethod", int.class);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            // 直接执行方法
            // targetMethod(128);
            // 反射调用
            method.invoke(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时:" + (end - start));
    }

推荐阅读更多精彩内容