Rendimiento en tiempo de ejecución de reflexión de Java

Question

Este es un ejercicio académico (exención de responsabilidad).

Estoy construyendo una aplicación que se beneficiará de ser lo más rápido posible ya que competirá con otros.

Sé que declarar una clase utilizando la reflexión (ejemplo a continuación) sufrirá una gran penalización en comparación con una declaración estándar.

Class mDefinition = Class.forName("MySpecialClassString"); 
Constructor mConstructor = mDefinition.getConstructor(new Class[]{MySpecialClass.class}); 
myClass = (MySpecialClass) mConstructor.newInstance(this); 

Sin embargo, después de declarar myClass si lo uso en una forma estándar myClass.myMethod()yo también sufrir de cerdos rendimiento o será el mismo que si hubiera declarado la clase de una manera estándar?

Answer 1

Habrá una penalización de rendimiento al crear una instancia por primera vez del objeto. Una vez que se carga la clase, es lo mismo que si se hubiera instanciado normalmente, y no habrá más penalización de rendimiento.

Yendo más lejos, si llama métodos utilizando reflexión, habrá una penalización de rendimiento de unas quince veces (por defecto en Java), después de lo cual la JVM reescribirá la llamada reflejada para que sea exactamente la misma que una compilación estática llamada. Por lo tanto, incluso las llamadas a métodos reflejados repetidamente no causarán una disminución en el rendimiento, una vez que el código de bytes haya sido recompilado por la JVM.

ver a estos dos enlace para obtener más información sobre lo siguiente:

• Any way to further optimize Java reflective method invocation?
• http://inferretuation.blogspot.com/2008/11/in-jit-we-trust.html

Answer 2

Una vez que la clase se haya cargado, debería estar bien. La sobrecarga está asociada con la inspección de las estructuras de tiempo de ejecución que representan la clase, etc. Los métodos de llamada en una forma estándar deberían estar bien, sin embargo, si comienza a buscar métodos por nombre o firma, incurrirá en gastos adicionales.

Answer 3

La respuesta de Chris Thompson es acertada. Sin embargo, estoy confundido por su ejemplo de código.

Esto cargará dinámicamente la clase:

Class mDefinition = Class.forName("MySpecialClassString"); 

esta forma se consigue un Contructor para su clase, lo que lleva a una instancia de esa misma clase como un argumento. También tenga en cuenta que está accediendo a la clase en tiempo de compilación con MySpecialClass.class:

Constructor mConstructor = mDefinition.getConstructor(new Class[]{MySpecialClass.class}); 

Esto se instancias de un MySpecialClass pasando this al constructor:

myClass = (MySpecialClass) mConstructor.newInstance(this); 

Con base en el argumento del constructor, ¿significa estamos en un método de instancia de MySpecialClass? Muy confundido.

EDIT: Esto está más cerca de lo que yo hubiera esperado ver:

Class<?> mDefinition = Class.forName("MySpecialClassString"); 

//constructor apparently takes this as argument 
Class<?> constructorArgType = this.getClass(); //could be ThisClassName.class 

Constructor<?> mConstructor = mDefinition.getConstructor(constructorArgType); 

MySpecialInterface mySpecialInstance = (MySpecialInterface)mConstructor.newInstance(this); 

donde MySpecialInterface es una interfaz que se utiliza para interactuar con sus clases de carga dinámica:

interface MySpecialInterface { 
    //methods used to interface with dynamically loaded classes 
} 

De todos modos por favor avísame si estoy mal entendido o fuera de base aquí.