En parlant de Java Quand on débute En contact avec les différentes fonctionnalités avancées de la réflexion, ils expriment souvent une grande excitation et utilisent même avec force la réflexion pour « montrer leurs compétences » dans certaines scènes qui ne nécessitent pas l'utilisation de la réflexion. Les personnes âgées plus expérimentées se posent souvent trois questions dans leur âme lorsqu'elles voient la réflexion : Pourquoi utiliser la réflexion ? La réflexion ne réduit-elle pas les performances ? Existe-t-il un autre moyen de résoudre ce problème ?
Alors aujourd'hui, nous allons discuter en profondeur de l'impact de la réflexion sur la performance ? Au fait, explorons pourquoi la réflexion affecte les performances ?
Expérience de codage
Avant d'analyser les principes spécifiques, nous pouvons tirer des conclusions en écrivant du code pour faire des expériences.
La réflexion peut impliquer de nombreux types d'opérations, telles que la génération d'instances, l'obtention/définition d'attributs de variables, l'appel de méthodes, etc. Après une simple réflexion, nous pensons que la génération d'instances a un plus grand impact sur les performances que d'autres opérations, nous utilisons donc la génération d'instances à des fins d'expérimentation.
Dans le code suivant, nous définissons une classe InnerClass Nous testons en utilisant respectivement new et 反射 pour générer MAX_TIMES et imprimer le temps écoulé.
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 {
}
}复制代码
utilise la réflexion pour générer 100 000 instances, ce qui prend 670 ms, ce qui est nettement supérieur aux 15 ms de l'utilisation directe du mot-clé new, donc les performances de réflexion sont faibles . Ne vous inquiétez pas, cette conclusion est un peu précoce. Essayons de changer le nombre total d'instances à générer à 1 000. Le journal de sortie est :
Utiliser la réflexion pour générer 1 000 instances, bien que cela prenne 9 ms, ce qui est supérieur à new 2 ms, mais la différence entre 9 ms et 2 ms est invisible à l'œil nu, et généralement la réflexion que nous écrivons en entreprise ne peut pas être exécutée plus de 1 000 fois. Dans ce scénario, nous pouvons à juste titre dire que le. les performances de réflexion sont très faibles.
Évidemment, non.
En plus du temps nécessaire à l’exécution du code, regardons l’impact de la réflexion sur la mémoire. Nous visons toujours à générer 100 000 instances et à apporter de légères modifications au code ci-dessus, en ne conservant tour à tour que la méthode new et la méthode de réflexion, puis à exécuter le programme et à observer l'utilisation de la mémoire.
Utilisez la méthode new
Utilisez la réflexion
En comparant les deux images, nous pouvons voir qu'il y a beaucoup plus d'instances d'objet Constructor et Class dans la deuxième image, et ces deux parties occupent 2,7 Mo de mémoire. Par conséquent, nous pouvons conclure que la réflexion générera un grand nombre d’objets temporaires et occupera de l’espace mémoire supplémentaire.
Allons au fond des choses : quel est le principe de la réflexion ?
Nous utilisons le code de l'instance de génération de réflexion dans l'expérience précédente comme point d'entrée.
Revoyez d'abord le cycle de vie des classes dans la machine virtuelle : chargement, connexion (vérification, préparation, analyse), initialisation, utilisation et désinstallation. Pendant le processus de chargement, la machine virtuelle convertit le bytecode de la classe en une structure de données d'exécution et l'enregistre dans la zone de méthode. Un objet java.lang.Class représentant la structure de données de cette classe sera généré dans la mémoire. à cette classe La structure des données est accessible via cet objet Class.
Dans le code, clazz.getDeclaredConstructor() est utilisé pour obtenir le constructeur défini dans la classe Puisque nous ne définissons pas explicitement le constructeur, nous renverrons le constructeur par défaut sans argument généré par le compilateur pour nous-mêmes.
Voyons comment getDeclaredConstructor renvoie le constructeur. Les éléments suivants sont tous basés sur le code jdk 1.8 comme code source. La méthode
Obtenir un tableau composé de toutes les méthodes de construction
Parcourir le tableau des méthodes de construction et trouver la correspondance
Il n'y a pas grand chose à dire sur la correspondance traversale. Concentrons-nous sur la première chose, comment obtenir le tableau de toutes les méthodes de construction, qui est cette méthode privateGetDeclaredConstructors.
private Constructor<T>[] privateGetDeclaredConstructors(boolean publicOnly) {
checkInitted();
Constructor<T>[] res; // 获取缓存的 ReflectionData 数据
ReflectionData<T> 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<T>[] temporaryRes = (Constructor<T>[]) 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;
}复制代码
Copier après la connexion
Dans le code ci-dessus, j'ai commenté le code clé Avant d'expliquer tout le processus, nous avons vu un type inconnu ReflectionData. Sa structure de données correspondante est :
private static class ReflectionData<T> { volatile Field[] declaredFields; volatile Field[] publicFields; volatile Method[] declaredMethods; volatile Method[] publicMethods; volatile Constructor<T>[] declaredConstructors; volatile Constructor<T>[] 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;
}
}复制代码
Copier après la connexion
ReflectionData Cette classe est utilisée pour sauvegarder certaines données obtenues à partir de la machine virtuelle. En même temps, nous pouvons voir que tous les attributs de réflexion sont modifiés avec le mot-clé volatile.
Obtenez les données ReflectionData mises en cache en appelant la méthode reflectionData().
// 定义在 Class 类中的反射缓存对象private volatile transient SoftReference<ReflectionData<T>> reflectionData;private ReflectionData<T> reflectionData() {
SoftReference<ReflectionData<T>> reflectionData = this.reflectionData; int classRedefinedCount = this.classRedefinedCount;
ReflectionData<T> 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);
}复制代码
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;
}复制代码
Copier après la connexion
接着看下 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;
}复制代码
Copier après la connexion
继续走到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;
}
}复制代码
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
