JAVA深入研究——Method的Invoke方法。

public final  class Method extends AccessibleObject implements GenericDeclaration,          Member {  // ...  private volatile MethodAccessor methodAccessor;  // For sharing of MethodAccessors. This branching structure is  // currently only two levels deep (i.e., one root Method and  // potentially many Method objects pointing to it.)  private Method     root;  // ...  public Object invoke(Object obj, Object... args)    throws IllegalAccessException, IllegalArgumentException,    InvocationTargetException  {   if (!override) {    if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {     Class caller = Reflection.getCallerClass(1);     Class targetClass = ((obj == null || !Modifier.isProtected(modifiers))           ? clazz           : obj.getClass());     boolean cached;     synchronized (this) {      cached = (securityCheckCache == caller)       && (securityCheckTargetClassCache == targetClass);     }     if (!cached) {      Reflection.ensureMemberAccess(caller, clazz, obj, modifiers);      synchronized (this) {      securityCheckCache = caller;      securityCheckTargetClassCache = targetClass;      }     }    }   }   if (methodAccessor == null) acquireMethodAccessor();   return methodAccessor.invoke(obj, args);  }  // NOTE that there is no synchronization used here. It is correct  // (though not efficient) to generate more than one MethodAccessor  // for a given Method. However, avoiding synchronization will  // probably make the implementation more scalable.  private void acquireMethodAccessor() {   // First check to see if one has been created yet, and take it   // if so   MethodAccessor tmp = null;   if (root != null) tmp = root.getMethodAccessor();   if (tmp != null) {    methodAccessor = tmp;    return;   }   // Otherwise fabricate one and propagate it up to the root   tmp = reflectionFactory.newMethodAccessor(this);   setMethodAccessor(tmp);  }  // ... } 

可以看到Method.invoke()实际上并不是自己实现的反射调用逻辑，而是委托给sun.reflect.MethodAccessor来处理。

每个实际的Java方法只有一个对应的Method对象作为root，。这个root是不会暴露给用户的，而是每次在通过反射获取Method对象时新创建Method对象把root包装起来再给用户。在第一次调用一个实际Java方法对应得Method对象的invoke()方法之前，实现调用逻辑的MethodAccessor对象还没创建；等第一次调用时才新创建MethodAccessor并更新给root，然后调用MethodAccessor.invoke()真正完成反射调用。 

那么MethodAccessor是啥呢？ 

public class ReflectionFactory {  private static boolean initted = false;  // ...  //  // "Inflation" mechanism. Loading bytecodes to implement  // Method.invoke() and Constructor.newInstance() currently costs  // 3-4x more than an invocation via native code for the first  // invocation (though subsequent invocations have been benchmarked  // to be over 20x faster). Unfortunately this cost increases  // startup time for certain applications that use reflection  // intensively (but only once per class) to bootstrap themselves.  // To avoid this penalty we reuse the existing JVM entry points  // for the first few invocations of Methods and Constructors and  // then switch to the bytecode-based implementations.  //  // Package-private to be accessible to NativeMethodAccessorImpl  // and NativeConstructorAccessorImpl  private static boolean noInflation  = false;  private static int  inflationThreshold = 15;  // ...  /** We have to defer full initialization of this class until after   the static initializer is run since java.lang.reflect.Method's   static initializer (more properly, that for   java.lang.reflect.AccessibleObject) causes this class's to be   run, before the system properties are set up. */  private static void checkInitted() {   if (initted) return;   AccessController.doPrivileged(new PrivilegedAction() {     public Object run() {      // Tests to ensure the system properties table is fully      // initialized. This is needed because reflection code is      // called very early in the initialization process (before      // command-line arguments have been parsed and therefore      // these user-settable properties installed.) We assume that      // if System.out is non-null then the System class has been      // fully initialized and that the bulk of the startup code      // has been run.      if (System.out == null) {       // java.lang.System not yet fully initialized       return null;      }      String val = System.getProperty("sun.reflect.noInflation");      if (val != null && val.equals("true")) {       noInflation = true;      }      val = System.getProperty("sun.reflect.inflationThreshold");      if (val != null) {       try {        inflationThreshold = Integer.parseInt(val);       } catch (NumberFormatException e) {        throw (RuntimeException)          new RuntimeException("Unable to parse property sun.reflect.inflationThreshold").          initCause(e);       }      }      initted = true;      return null;     }    });  }  // ...  public MethodAccessor newMethodAccessor(Method method) {   checkInitted();   if (noInflation) {    return new MethodAccessorGenerator().     generateMethod(method.getDeclaringClass(),           method.getName(),           method.getParameterTypes(),           method.getReturnType(),           method.getExceptionTypes(),           method.getModifiers());   } else {    NativeMethodAccessorImpl acc =     new NativeMethodAccessorImpl(method);    DelegatingMethodAccessorImpl res =     new DelegatingMethodAccessorImpl(acc);    acc.setParent(res);    return res;   }  } } 

这里就可以看到有趣的地方了。如注释所述，实际的MethodAccessor实现有两个版本，一个是Java实现的，另一个是native code实现的。Java实现的版本在初始化时需要较多时间，但长久来说性能较好；native版本正好相反，启动时相对较快，但运行时间长了之后速度就比不过Java版了。这是HotSpot的优化方式带来的性能特性，同时也是许多虚拟机的共同点：跨越native边界会对优化有阻碍作用，它就像个黑箱一样让虚拟机难以分析也将其内联，于是运行时间长了之后反而是托管版本的代码更快些。

为了权衡两个版本的性能，Sun的JDK使用了“inflation”的技巧：让Java方法在被反射调用时，开头若干次使用native版，等反射调用次数超过阈值时则生成一个专用的MethodAccessor实现类，生成其中的invoke()方法的字节码，以后对该Java方法的反射调用就会使用Java版。 

Sun的JDK是从1.4系开始采用这种优化的。

/** Delegates its invocation to another MethodAccessorImpl and can  change its delegate at run time. */ class DelegatingMethodAccessorImpl extends MethodAccessorImpl {  private MethodAccessorImpl delegate;  DelegatingMethodAccessorImpl(MethodAccessorImpl delegate) {   setDelegate(delegate);  }   public Object invoke(Object obj, Object[] args)   throws IllegalArgumentException, InvocationTargetException  {   return delegate.invoke(obj, args);  }  void setDelegate(MethodAccessorImpl delegate) {   this.delegate = delegate;  } } 

/** Used only for the first few invocations of a Method; afterward,  switches to bytecode-based implementation */ class NativeMethodAccessorImpl extends MethodAccessorImpl {  private Method method;  private DelegatingMethodAccessorImpl parent;  private int numInvocations;  NativeMethodAccessorImpl(Method method) {   this.method = method;  }   public Object invoke(Object obj, Object[] args)   throws IllegalArgumentException, InvocationTargetException  {   if (++numInvocations > ReflectionFactory.inflationThreshold()) {    MethodAccessorImpl acc = (MethodAccessorImpl)     new MethodAccessorGenerator().      generateMethod(method.getDeclaringClass(),            method.getName(),            method.getParameterTypes(),            method.getReturnType(),            method.getExceptionTypes(),            method.getModifiers());    parent.setDelegate(acc);   }   return invoke0(method, obj, args);  }  void setParent(DelegatingMethodAccessorImpl parent) {   this.parent = parent;  }  private static native Object invoke0(Method m, Object obj, Object[] args); } 

JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))   JVMWrapper("JVM_InvokeMethod");   Handle method_handle;   if (thread->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) {     method_handle = Handle(THREAD, JNIHandles::resolve(method));     Handle receiver(THREAD, JNIHandles::resolve(obj));     objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));     oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);     jobject res = JNIHandles::make_local(env, result);     if (JvmtiExport::should_post_vm_object_alloc()) {       oop ret_type = java_lang_reflect_Method::return_type(method_handle());       assert(ret_type != NULL, "sanity check: ret_type oop must not be NULL!");       if (java_lang_Class::is_primitive(ret_type)) {         // Only for primitive type vm allocates memory for java object.         // See box() method.         JvmtiExport::post_vm_object_alloc(JavaThread::current(), result);       }     }     return res;   } else {     THROW_0(vmSymbols::java_lang_StackOverflowError());   } JVM_END

// This would be nicer if, say, java.lang.reflect.Method was a subclass // of java.lang.reflect.Constructor  oop Reflection::invoke_method(oop method_mirror, Handle receiver, objArrayHandle args, TRAPS) {   oop mirror             = java_lang_reflect_Method::clazz(method_mirror);   int slot               = java_lang_reflect_Method::slot(method_mirror);   bool override          = java_lang_reflect_Method::override(method_mirror) != 0;   objArrayHandle ptypes(THREAD, objArrayOop(java_lang_reflect_Method::parameter_types(method_mirror)));    oop return_type_mirror = java_lang_reflect_Method::return_type(method_mirror);   BasicType rtype;   if (java_lang_Class::is_primitive(return_type_mirror)) {     rtype = basic_type_mirror_to_basic_type(return_type_mirror, CHECK_NULL);   } else {     rtype = T_OBJECT;   }    instanceKlassHandle klass(THREAD, java_lang_Class::as_klassOop(mirror));   methodOop m = klass->method_with_idnum(slot);   if (m == NULL) {     THROW_MSG_0(vmSymbols::java_lang_InternalError(), "invoke");   }   methodHandle method(THREAD, m);    return invoke(klass, method, receiver, override, ptypes, rtype, args, true, THREAD); }

private static synchronized String generateName(boolean isConstructor,             boolean forSerialization) {  if (isConstructor) {   if (forSerialization) {    int num = ++serializationConstructorSymnum;    return "sun/reflect/GeneratedSerializationConstructorAccessor" + num;   } else {    int num = ++constructorSymnum;    return "sun/reflect/GeneratedConstructorAccessor" + num;   }  } else {   int num = ++methodSymnum;   return "sun/reflect/GeneratedMethodAccessor" + num;  } } 

package sun.reflect; public class GeneratedMethodAccessor1 extends MethodAccessorImpl {   public GeneratedMethodAccessor1() {   super();  }  public Object invoke(Object obj, Object[] args)      throws IllegalArgumentException, InvocationTargetException {   // prepare the target and parameters   if (obj == null) throw new NullPointerException();   try {    A target = (A) obj;    if (args.length != 1) throw new IllegalArgumentException();    String arg0 = (String) args[0];   } catch (ClassCastException e) {    throw new IllegalArgumentException(e.toString());   } catch (NullPointerException e) {    throw new IllegalArgumentException(e.toString());   }   // make the invocation   try {    target.foo(arg0);   } catch (Throwable t) {    throw new InvocationTargetException(t);   }  } } 

----------------------------------------------------------题外话------------------------------------------

当该反射调用成为热点时，它甚至可以被内联到靠近Method.invoke()的一侧，大大降低了反射调用的开销。而native版的反射调用则无法被有效内联，因而调用开销无法随程序的运行而降低。 

虽说Sun的JDK这种实现方式使得反射调用方法成本比以前降低了很多，但Method.invoke()本身要用数组包装参数；而且每次调用都必须检查方法的可见性（在Method.invoke()里），也必须检查每个实际参数与形式参数的类型匹配性（在NativeMethodAccessorImpl.invoke0()里或者生成的Java版MethodAccessor.invoke()里）；而且Method.invoke()就像是个独木桥一样，各处的反射调用都要挤过去，在调用点上收集到的类型信息就会很乱，影响内联程序的判断，使得Method.invoke()自身难以被内联到调用方。 

相比之下JDK7里新的MethodHandler则更有潜力，在其功能完全实现后能达到比普通反射调用方法更高的性能。在使用MethodHandle来做反射调用时，MethodHandle.invoke()的形式参数与返回值类型都是准确的，所以只需要在链接方法的时候才需要检查类型的匹配性，而不必在每次调用时都检查。而且MethodHandle是不可变值，在创建后其内部状态就不会再改变了；JVM可以利用这个知识而放心的对它做激进优化，例如将实际的调用目标内联到做反射调用的一侧。 

package sun.reflect; /** <P> MagicAccessorImpl (named for parity with FieldAccessorImpl and  others, not because it actually implements an interface) is a  marker class in the hierarchy. All subclasses of this class are  "magically" granted access by the VM to otherwise inaccessible  fields and methods of other classes. It is used to hold the code  for dynamically-generated FieldAccessorImpl and MethodAccessorImpl  subclasses. (Use of the word "unsafe" was avoided in this class's  name to avoid confusion with {@link sun.misc.Unsafe}.) </P>  <P> The bug fix for 4486457 also necessitated disabling  verification for this class and all subclasses, as opposed to just  SerializationConstructorAccessorImpl and subclasses, to avoid  having to indicate to the VM which of these dynamically-generated  stub classes were known to be able to pass the verifier. </P>  <P> Do not change the name of this class without also changing the  VM's code. </P> */ class MagicAccessorImpl { } 

// common code for JVM_DefineClass() and JVM_DefineClassWithSource() // and JVM_DefineClassWithSourceCond() static jclass jvm_define_class_common(JNIEnv *env, const char *name,                                       jobject loader, const jbyte *buf,                                       jsize len, jobject pd, const char *source,                                       jboolean verify, TRAPS) {   if (source == NULL)  source = "__JVM_DefineClass__";