[関連する学習の推奨事項:Java 基本チュートリアル ]
リフレクションは良いのか悪いのか
Java について話す 初心者が最初にリフレクションのさまざまな高度な機能に触れると、彼らは多くの場合大きな興奮を表現し、リフレクションを使用する必要のないシーンでは「スキルを誇示する」ためにリフレクションを強制的に使用することさえあります。経験豊富な高齢者は、反射を見たときに心の中で 3 つの疑問を抱くことがよくあります。なぜ反射を使用するのでしょうか。反射によってパフォーマンスが低下することはありませんか?この問題を解決する他の方法はありますか?
それでは、今日は、リフレクションがパフォーマンスにどの程度の影響を与えるかについて詳しく説明します。ところで、反射がパフォーマンスに影響を与える理由を調べてみましょう。
コーディング実験
具体的な原理を分析する前に、コードを書いて実験することで結論を導き出すことができます。
リフレクションには、インスタンスの生成、変数属性の取得/設定、メソッドの呼び出しなど、さまざまなタイプの操作が含まれる場合があります。単純に考えてみると、インスタンスの生成は他の操作よりもパフォーマンスに大きな影響を与えると考えられるため、実験にはインスタンスの生成を使用します。
次のコードでは、クラスInnerClassを定義し、newとreflectionをそれぞれ使用してテストし、MAX_TIMES# を生成します。 ## インスタンスを作成し、経過時間を出力します。
public class MainActivity extends AppCompatActivity { private static final String TAG = "MainAc"; private final int MAX_TIMES = 100 * 1000; private InnerClass innerList[]; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); innerList = new InnerClass[MAX_TIMES]; long startTime = SystemClock.elapsedRealtime(); for (int i=0; i < MAX_TIMES; i++) { innerList[i] = new InnerClass(); } Log.e(TAG, "totalTime: " + (SystemClock.elapsedRealtime() - startTime)); long startTime2 = SystemClock.elapsedRealtime(); for (int i=0; i < MAX_TIMES; i++) { innerList[i] = newInstanceByReflection(); } Log.e(TAG, "totalTime2: " + (SystemClock.elapsedRealtime() - startTime2)); } public InnerClass newInstanceByReflection() { Class clazz = InnerClass.class; try { return (InnerClass) clazz.getDeclaredConstructor().newInstance(); } catch (NoSuchMethodException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } return null; } static class InnerClass { } }复制代码
ログイン後にコピー
出力ログ:
2020-03-19 22:34:49.738 2151-2151/? E/MainAc: totalTime: 15 2020-03-19 22:34:50.409 2151-2151/? E/MainAc: totalTime2: 670复制代码
ログイン後にコピー
リフレクションを使用して 100,000 個のインスタンスを生成するには 670 ミリ秒かかります。これは、
newキーワードを直接使用した場合の 15 ミリ秒よりも大幅に長いため、リフレクションのパフォーマンスは低下します。低い 。結論は少し早いので心配しないで、生成するインスタンスの総数を 1000 に変更してログを出力してみましょう:
2020-03-19 22:39:21.287 3641-3641/com.example.myapplication E/MainAc: totalTime: 2 2020-03-19 22:39:21.296 3641-3641/com.example.myapplication E/MainAc: totalTime2: 9复制代码
ログイン後にコピー
リフレクションを使用して 1000 個のインスタンスを生成しますが、9ms かかりますが、これは new
の2ms よりも高いですが、9ms と 2ms の差は肉眼では見えず、通常、ビジネスで作成するリフレクションは 1,000 回を超えて実行されることはありません。それでも自信を持って言えますが、反射性能は非常に低いのでしょうか？
明らかに、いいえ。
コードの実行にかかる時間に加えて、メモリに対するリフレクションの影響を見てみましょう。引き続き 100,000 個のインスタンスを生成することを目標としており、上記のコードにわずかな変更を加えて、
newメソッドとリフレクション メソッドのみを順番に保持し、プログラムを実行してメモリ使用量を観察します。
#new
メソッドを使用する
2 つの図を比較すると、2 番目の図にはさらに多くの
Constructor
およびClassオブジェクト インスタンスがあることがわかります。これら 2 つの部分は 2.7M を占めています。記憶の。したがって、リフレクションによって大量の一時オブジェクトが生成され、追加のメモリ領域が占有されると結論付けることができます。
前の実験のリフレクション生成インスタンスのコードをエントリ ポイントとして使用します。
まず、仮想マシン内のクラスのライフ サイクル (ロード、接続 (検証、準備、解析)、初期化、使用、アンインストール) を確認します。ロード処理中に、仮想マシンはクラスのバイトコードをランタイム データ構造に変換してメソッド領域に保存し、このクラスのデータ構造を表す java.lang.Class オブジェクトがメモリ内に生成されます。このクラスへ この Class オブジェクトを通じてデータ構造にアクセスできます。
public InnerClass newInstanceByReflection() { // 获取虚拟机中 InnerClass 类的 Class 对象 Class clazz = InnerClass.class; try { return (InnerClass) clazz.getDeclaredConstructor().newInstance(); } catch (NoSuchMethodException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } catch (InvocationTargetException e) { e.printStackTrace(); } return null; }复制代码
ログイン後にコピー
コードでは、
clazz.getDeclaredConstructor()
を使用して、クラスに定義されているコンストラクター メソッドを取得します。コンストラクター メソッドを明示的に定義していないため、コンパイラによって生成されるデフォルト値が使用されます。引数なしの構築方法。
がどのようにコンストラクターを返すかを見てみましょう。以下はすべて、ソース コードとして jdk 1.8 コードに基づいています。
@CallerSensitivepublic Constructor getDeclaredConstructor(Class... parameterTypes) throws NoSuchMethodException, SecurityException { // 权限检查 checkMemberAccess(Member.DECLARED, Reflection.getCallerClass(), true); return getConstructor0(parameterTypes, Member.DECLARED); }复制代码
ログイン後にコピー
getDeclaredConstructor
メソッドは、最初に権限を確認してから、
getConstructor0メソッドを直接呼び出します。
private Constructor getConstructor0(Class[] parameterTypes, int which) throws NoSuchMethodException{ // privateGetDeclaredConstructors 方法是获取所有的构造方法数组 Constructor[] constructors = privateGetDeclaredConstructors((which == Member.PUBLIC)); // 遍历所有的构造方法数组，根据传入的参数类型依次匹配，找到合适的构造方法后就会拷贝一份作为返回值 for (Constructor constructor : constructors) { if (arrayContentsEq(parameterTypes, constructor.getParameterTypes())) { // 拷贝构造方法 return getReflectionFactory().copyConstructor(constructor); } } // 没有找到的话，就抛出异常 throw new NoSuchMethodException(getName() + "." + argumentTypesToString(parameterTypes)); }复制代码
ログイン後にコピー
getConstructor0
このメソッドは主に 2 つのことを行います:
構築メソッドの配列を走査します。そして、Matching
トラバーサル マッチングについては何も言うことはありません。最初に、すべてのコンストラクターの配列を取得する方法 (このメソッド privateGetDeclaredConstructors
) に焦点を当てましょう。
private Constructor[] privateGetDeclaredConstructors(boolean publicOnly) { checkInitted(); Constructor[] res; // 获取缓存的 ReflectionData 数据 ReflectionData rd = reflectionData(); // 如果缓存中有 ReflectionData，就先看看 ReflectionData 中的 publicConstructors 或 declaredConstructors是否为空 if (rd != null) { res = publicOnly ? rd.publicConstructors : rd.declaredConstructors; if (res != null) return res; } // 如果没有缓存，或者缓存中构造方法数组为空 // No cached value available; request value from VM // 对接口类型的字节码特殊处理 if (isInterface()) { @SuppressWarnings("unchecked") // 如果是接口类型，那么生成一个长度为0的构造方法数组 Constructor[] temporaryRes = (Constructor[]) new Constructor[0]; res = temporaryRes; } else { // 如果不是接口类型，就调用 getDeclaredConstructors0 获取构造方法数组 res = getDeclaredConstructors0(publicOnly); } // 获取到构造方法数组后，再赋值给缓存 ReflectionData 中的对应属性 if (rd != null) { if (publicOnly) { rd.publicConstructors = res; } else { rd.declaredConstructors = res; } } return res; }复制代码
ログイン後にコピー
上のコードでは、キー コードをコメント化しましたが、プロセス全体を説明する前に、見慣れない型ReflectionData
を確認しました。対応するデータ構造は次のとおりです。
private static class ReflectionData { volatile Field[] declaredFields; volatile Field[] publicFields; volatile Method[] declaredMethods; volatile Method[] publicMethods; volatile Constructor[] declaredConstructors; volatile Constructor[] publicConstructors; // Intermediate results for getFields and getMethods volatile Field[] declaredPublicFields; volatile Method[] declaredPublicMethods; volatile Class[] interfaces; // Value of classRedefinedCount when we created this ReflectionData instance final int redefinedCount; ReflectionData(int redefinedCount) { this.redefinedCount = redefinedCount; } }复制代码
ログイン後にコピー
ReflectionData
このクラスは、仮想マシンから取得したデータを保存するために使用されます。同時に、すべてのリフレクション プロパティが
volatileキーワードで変更されていることがわかります。キャッシュされたReflectionData
データを取得するには、
reflectionData()メソッドを呼び出します。
// 定义在 Class 类中的反射缓存对象private volatile transient SoftReference> reflectionData;private ReflectionData reflectionData() { SoftReference> reflectionData = this.reflectionData; int classRedefinedCount = this.classRedefinedCount; ReflectionData rd; if (useCaches && reflectionData != null && (rd = reflectionData.get()) != null && rd.redefinedCount == classRedefinedCount) { return rd; } // else no SoftReference or cleared SoftReference or stale ReflectionData // -> create and replace new instance return newReflectionData(reflectionData, classRedefinedCount); }复制代码
ログイン後にコピー
我们可以看到reflectionData实际上是一个软引用，软引用会在内存不足的情况下被虚拟机回收，所以reflectionData()方法在开始的地方，先判断了是否可以使用缓存以及缓存是否失效，如果失效了，就会调用newReflectionData方法生成一个新的ReflectionData实例。
接下来看看newReflectionData方法。
private ReflectionData newReflectionData(SoftReference> oldReflectionData, int classRedefinedCount) { // 如果不允许使用缓存，直接返回 null if (!useCaches) return null; while (true) { ReflectionData rd = new ReflectionData<>(classRedefinedCount); // try to CAS it... if (Atomic.casReflectionData(this, oldReflectionData, new SoftReference<>(rd))) { return rd; } // else retry oldReflectionData = this.reflectionData; classRedefinedCount = this.classRedefinedCount; if (oldReflectionData != null && (rd = oldReflectionData.get()) != null && rd.redefinedCount == classRedefinedCount) { return rd; } } }复制代码
ログイン後にコピー
newReflectionData中使用volatile + 死循环 + CAS 机制 保证线程安全。注意到这里的死循环每执行一次都会构造一个新的ReflectionData实例。
你可能会有疑问，Class中reflectionData属性什么时候被赋值的，其实是封装在Atomic.casReflectionData这个方法里了，他会检测当前Class对象中的reflectionData是否与oldReflectionData相等，如果相等，就会把new SoftReference<>(rd)赋值给reflectionData。
到现在为止，关于ReflectionData的背景知识都介绍完了。我们再回到privateGetDeclaredConstructors中看看获取构造方法的流程。
privateGetDeclaredConstructors流程图
可以看到对于普通类，最终通过调用getDeclaredConstructors0方法获取的构造方法列表。
private native Constructor[] getDeclaredConstructors0(boolean publicOnly);复制代码
ログイン後にコピー
这个方法是 native 的，具体逻辑在 jdk 源码中。
在native/java/lang/Class_getDeclaredConstructors0.c文件中，
void getDeclaredConstructors0(Frame * frame){ // Frame 可以理解为调用native方法时，java层传递过来的数据的一种封装 LocalVars * vars = frame->localVars; Object * classObj = getLocalVarsThis(vars); // 取得java方法的入参 bool publicOnly = getLocalVarsBoolean(vars, 1); uint16_t constructorsCount = 0; // 获取要查询的类的 Class 对象 Class * c = classObj->extra; // 获取这个类的所有构造方法，且数量保存在 constructorsCount 中 Method* * constructors = getClassConstructors(c, publicOnly, &constructorsCount); // 获取 java 方法调用所属的 classLoader ClassLoader * classLoader = frame->method->classMember.attachClass->classLoader; // 拿到 Constructor 对应的 class 对象 Class * constructorClass = loadClass(classLoader, "java/lang/reflect/Constructor"); //创建一个长度为 constructorsCount 的数组保存构造方法 Object * constructorArr = newArray(arrayClass(constructorClass), constructorsCount); pushOperandRef(frame->operandStack, constructorArr); // 后面是具体的赋值逻辑。将native中的Method对象转化为java层的Constructor对象 if (constructorsCount > 0) { Thread * thread = frame->thread; Object* * constructorObjs = getObjectRefs(constructorArr); Method * constructorInitMethod = getClassConstructor(constructorClass, _constructorConstructorDescriptor); for (uint16_t i = 0; i < constructorsCount; i++) { Method * constructor = constructors[i]; Object * constructorObj = newObject(constructorClass); constructorObj->extra = constructor; constructorObjs[i] = constructorObj; OperandStack * ops = newOperandStack(9); pushOperandRef(ops, constructorObj); pushOperandRef(ops, classObj); pushOperandRef(ops, toClassArr(classLoader, methodParameterTypes(constructor), constructor->parsedDescriptor->parameterTypesCount)); if (constructor->exceptions != NULL) pushOperandRef(ops, toClassArr(classLoader, methodExceptionTypes(constructor), constructor->exceptions->number_of_exceptions)); else pushOperandRef(ops, toClassArr(classLoader, methodExceptionTypes(constructor), 0)); pushOperandInt(ops, constructor->classMember.accessFlags); pushOperandInt(ops, 0); pushOperandRef(ops, getSignatureStr(classLoader, constructor->classMember.signature)); // signature pushOperandRef(ops, toByteArr(classLoader, constructor->classMember.annotationData, constructor->classMember.annotationDataLen)); pushOperandRef(ops, toByteArr(classLoader, constructor->parameterAnnotationData, constructor->parameterAnnotationDataLen)); Frame * shimFrame = newShimFrame(thread, ops); pushThreadFrame(thread, shimFrame); // init constructorObj InvokeMethod(shimFrame, constructorInitMethod); } } }复制代码
ログイン後にコピー
从上面的逻辑，可以知道获取构造方法的核心方法是getClassConstructors，所在文件为rtda/heap/class.c。
Method* * getClassConstructors(Class * self, bool publicOnly, uint16_t * constructorsCount){ // 分配大小为 sizeof(Method) 的长度为 methodsCount 的连续内存地址，即数组 Method* * constructors = calloc(self->methodsCount, sizeof(Method)); *constructorsCount = 0; // 在native 层，构造方法和普通方法都存在 methods 中，逐一遍历 for (uint16_t i = 0; i < self->methodsCount; i++) { Method * method = self->methods + i; // 判断是否是构造方法 if (isMethodConstructor(method)) { // 检查权限 if (!publicOnly || isMethodPublic(method)) { // 符合条件的构造方法依次存到数组中 constructors[*constructorsCount] = method; (*constructorsCount)++; } } } return constructors; }复制代码
ログイン後にコピー
可以看到getClassConstructors实际上就是对methods进行了一次过滤，过滤的条件为：1.是构造方法；2.权限一致。
isMethodConstructor方法的判断逻辑也是十分简单，不是静态方法，而且方法名是
bool isMethodConstructor(Method * self){ return !isMethodStatic(self) && strcmp(self->classMember.name, "") == 0; }复制代码
ログイン後にコピー
所以核心的逻辑变成了Class中的methods数组何时被初始化赋值的？我们刨根问底的追踪下。
我们先找到类加载到虚拟机中的入口方法loadNonArrayClass：
Class * loadNonArrayClass(ClassLoader * classLoader, const char * className){ int32_t classSize = 0; char * classContent = NULL; Class * loadClass = NULL; classSize = readClass(className, &classContent); if (classSize > 0 && classContent != NULL){#if 0 printf("class size:%d,class data:[", classSize); for (int32_t i = 0; i < classSize; i++) { printf("0x%02x ", classContent[i]); } printf("]\n");#endif } if (classSize <= 0) { printf("Could not found target class\n"); exit(127); } // 解析字节码文件 loadClass = parseClassFile(classContent, classSize); loadClass->classLoader = classLoader; // 加载 defineClass(classLoader, loadClass); // 链接 linkClass(classLoader, loadClass); //printf("[Loaded %s\n", loadClass->name); return loadClass; }复制代码
ログイン後にコピー
在parseClassFile方法中，调用了newClass方法。
Class * parseClassFile(char * classContent, int32_t classSize){ ClassFile * classFile = NULL; classFile = parseClassData(classContent, classSize); return newClass(classFile); }复制代码
ログイン後にコピー
newClass方法在rtda/heap/class.c文件中。
Class * newClass(ClassFile * classFile){ Class * c = calloc(1, sizeof(Class)); c->accessFlags = classFile->accessFlags; c->sourceFile = getClassSourceFileName(classFile); newClassName(c, classFile); newSuperClassName(c, classFile); newInterfacesName(c, classFile); newConstantPool(c, classFile); newFields(c, classFile); newMethods(c, classFile); return c; }复制代码
ログイン後にコピー
可以看到，在native层创建了一个Class对象，我们重点看newMethods(c, classFile)方法啊，这个方法定义在rtda/heap/method.c中。
Method * newMethods(struct Class * c, ClassFile * classFile){ c->methodsCount = classFile->methodsCount; c->methods = NULL; if (c->methodsCount == 0) return NULL; c->methods = calloc(classFile->methodsCount, sizeof(Method)); for (uint16_t i = 0; i < c->methodsCount; i++) { c->methods[i].classMember.attachClass = c; copyMethodInfo(&c->methods[i], &classFile->methods[i], classFile); copyAttributes(&c->methods[i], &classFile->methods[i], classFile); MethodDescriptor * md = parseMethodDescriptor(c->methods[i].classMember.descriptor); c->methods[i].parsedDescriptor = md; calcArgSlotCount(&c->methods[i]); if (isMethodNative(&c->methods[i])) { injectCodeAttribute(&c->methods[i], md->returnType); } } return NULL; }复制代码
ログイン後にコピー
上述代码可以看出，实际上就是把ClassFile中解析到的方法逐一赋值给了Class对象的methods数组。
总算梳理清楚了，反射创建对象的调用链为：
loadClass -> loadNonArrayClass -> parseClassFile -> newMethods -> Class 的 methods数组 privateGetDeclaredConstructors -> getDeclaredConstructors0 -> getClassConstructors (过滤Class 的 methods数组)复制代码
ログイン後にコピー
到目前为止，我们搞明白反射时如何找到对应的构造方法的。下面我们来看newInstance方法。
(InnerClass) clazz.getDeclaredConstructor().newInstance();复制代码
ログイン後にコピー
public T newInstance(Object ... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { // 构造方法是否被重载了 if (!override) { if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) { Class caller = Reflection.getCallerClass(); // 检查权限 checkAccess(caller, clazz, null, modifiers); } } // 枚举类型报错 if ((clazz.getModifiers() & Modifier.ENUM) != 0) throw new IllegalArgumentException("Cannot reflectively create enum objects"); // ConstructorAccessor 是缓存的，如果为空，就去创建一个 ConstructorAccessor ca = constructorAccessor; // read volatile if (ca == null) { // 创建 ConstructorAccessor ca = acquireConstructorAccessor(); } @SuppressWarnings("unchecked") // 使用 ConstructorAccessor 的 newInstance 构造实例 T inst = (T) ca.newInstance(initargs); return inst; }复制代码
ログイン後にコピー
接着看下acquireConstructorAccessor方法。
private ConstructorAccessor acquireConstructorAccessor() { // First check to see if one has been created yet, and take it // if so. ConstructorAccessor tmp = null; // 可以理解为缓存的对象 if (root != null) tmp = root.getConstructorAccessor(); if (tmp != null) { constructorAccessor = tmp; } else { // Otherwise fabricate one and propagate it up to the root // 生成一个 ConstructorAccessor，并缓存起来 tmp = reflectionFactory.newConstructorAccessor(this); setConstructorAccessor(tmp); } return tmp; }复制代码
ログイン後にコピー
继续走到newConstructorAccessor方法。
public ConstructorAccessor newConstructorAccessor(Constructor var1) { checkInitted(); Class var2 = var1.getDeclaringClass(); // 如果是抽象类，报错 if (Modifier.isAbstract(var2.getModifiers())) { return new InstantiationExceptionConstructorAccessorImpl((String)null); } // 如果 Class 类报错 else if (var2 == Class.class) { return new InstantiationExceptionConstructorAccessorImpl("Can not instantiate java.lang.Class"); } // 如果是 ConstructorAccessorImpl 的子类的话，返回 BootstrapConstructorAccessorImpl else if (Reflection.isSubclassOf(var2, ConstructorAccessorImpl.class)) { return new BootstrapConstructorAccessorImpl(var1); } // 判断 noInflation , 后面是判断不是匿名类 else if (noInflation && !ReflectUtil.isVMAnonymousClass(var1.getDeclaringClass())) { return (new MethodAccessorGenerator()).generateConstructor(var1.getDeclaringClass(), var1.getParameterTypes(), var1.getExceptionTypes(), var1.getModifiers()); } // 使用 NativeConstructorAccessorImpl 来生成实例 else { NativeConstructorAccessorImpl var3 = new NativeConstructorAccessorImpl(var1); DelegatingConstructorAccessorImpl var4 = new DelegatingConstructorAccessorImpl(var3); var3.setParent(var4); return var4; } }复制代码
ログイン後にコピー
具体逻辑，在上述代码中已经注释了。这里提一下noInflation。
ReflectionFactory在执行所有方法前会检查下是否执行过了checkInitted方法，这个方法会把noInflation的值和inflationThreshold从虚拟机的环境变量中读取出来并赋值。
当noInflation为false而且不是匿名类时，就会使用MethodAccessorGenerator方式。否则就是用NativeConstructorAccessorImpl的方式来生成。
默认noInflation为false，所以我们先看native调用的方式。关注NativeConstructorAccessorImpl类。
class NativeConstructorAccessorImpl extends ConstructorAccessorImpl { private final Constructor c; private DelegatingConstructorAccessorImpl parent; private int numInvocations; NativeConstructorAccessorImpl(Constructor var1) { this.c = var1; } public Object newInstance(Object[] var1) throws InstantiationException, IllegalArgumentException, InvocationTargetException { if (++this.numInvocations > ReflectionFactory.inflationThreshold() && !ReflectUtil.isVMAnonymousClass(this.c.getDeclaringClass())) { ConstructorAccessorImpl var2 = (ConstructorAccessorImpl)(new MethodAccessorGenerator()).generateConstructor(this.c.getDeclaringClass(), this.c.getParameterTypes(), this.c.getExceptionTypes(), this.c.getModifiers()); this.parent.setDelegate(var2); } return newInstance0(this.c, var1); } void setParent(DelegatingConstructorAccessorImpl var1) { this.parent = var1; } private static native Object newInstance0(Constructor var0, Object[] var1) throws InstantiationException, IllegalArgumentException, InvocationTargetException; }复制代码
ログイン後にコピー
我们可以看到NativeConstructorAccessorImpl中维护了一个计数器numInvocations,在每次调用newInstance方法生成实例时，就会对计数器自增，当计数器超过ReflectionFactory.inflationThreshold()的阈值，默认为15，就会使用ConstructorAccessorImpl替换NativeConstructorAccessorImpl,后面就会直接调用MethodAccessorGenerator中的方法了。
我们先看看没到达阈值前，会调用native方法newInstance0,这个方法定义在native/sun/reflect/NativeConstructorAccessorImpl.c中，具体newInstance0的流程我就不分析了，大致逻辑是操作堆栈执行方法。
然后我们再看看超过阈值后，执行的是MethodAccessorGenerator生成构造器的方式。这种方式与newConstructorAccessor方法中noInflation为false的处理方式一样。所以可以解释为：java虚拟机在执行反射操作时，如果同一操作执行次数超过阈值，会从native生成实例的方式转变为java生成实例的方式。
MethodAccessorGenerator的MethodAccessorGenerator方法如下。
public ConstructorAccessor generateConstructor(Class var1, Class[] var2, Class[] var3, int var4) { return (ConstructorAccessor)this.generate(var1, "", var2, Void.TYPE, var3, var4, true, false, (Class)null); }复制代码
ログイン後にコピー
继续跟踪下去可以发现，反射调用构造方法实际上是动态编写字节码，并且在虚拟机中把编好的字节码加载成一个Class，这个Class实际上是ConstructorAccessorImpl类型的，然后调用这个动态类的newInstance方法。回看刚刚我们梳理的newConstructorAccessor代码，可以看到第三个逻辑：
// 如果是 ConstructorAccessorImpl 的子类的话，返回 BootstrapConstructorAccessorImpl else if (Reflection.isSubclassOf(var2, ConstructorAccessorImpl.class)) { return new BootstrapConstructorAccessorImpl(var1); } 复制代码
ログイン後にコピー
最终执行的是BootstrapConstructorAccessorImpl的newInstance方法。
class BootstrapConstructorAccessorImpl extends ConstructorAccessorImpl { private final Constructor constructor; BootstrapConstructorAccessorImpl(Constructor var1) { this.constructor = var1; } public Object newInstance(Object[] var1) throws IllegalArgumentException, InvocationTargetException { try { return UnsafeFieldAccessorImpl.unsafe.allocateInstance(this.constructor.getDeclaringClass()); } catch (InstantiationException var3) { throw new InvocationTargetException(var3); } } }复制代码
ログイン後にコピー
最后是通过使用Unsafe类分配了一个实例。
反射带来的问题
到现在为止，我们已经把反射生成实例的所有流程都搞清楚了。回到文章开头的问题，我们现在反思下，反射性能低么？为什么？
反射调用过程中会产生大量的临时对象，这些对象会占用内存，可能会导致频繁 gc，从而影响性能。
反射调用方法时会从方法数组中遍历查找，并且会检查可见性等操作会耗时。
反射在达到一定次数时，会动态编写字节码并加载到内存中，这个字节码没有经过编译器优化，也不能享受JIT优化。
反射一般会涉及自动装箱/拆箱和类型转换，都会带来一定的资源开销。
在Android中，我们可以在某些情况下对反射进行优化。举个例子，EventBus 2.x 会在 register 方法运行时，遍历所有方法找到回调方法；而EventBus 3.x 则在编译期间，将所有回调方法的信息保存的自己定义的SubscriberMethodInfo中，这样可以减少对运行时的性能影响。
想了解更多相关学习，敬请关注php培训 栏目！
以上がJava リフレクションの速度について話すの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。
![[Web フロントエンド] Node.js クイック スタート](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
