Implicaciones de la eficiencia de la clase anónima de Java

Question

¿Hay alguna diferencia en la eficiencia (por ejemplo, el tiempo de ejecución, el tamaño del código, etc.) entre estas dos formas de hacer las cosas?

A continuación se encuentran ejemplos diseñados que crean objetos y no hacen nada, pero mis escenarios reales pueden estar creando nuevos hilos, oyentes, etc. Suponga que las siguientes piezas de código ocurren en un bucle para que pueda marcar la diferencia.

Uso de objetos anónimos:

void doSomething() { 
    for (/* Assume some loop */) { 
     final Object obj1, obj2; // some free variables 

     IWorker anonymousWorker = new IWorker() { 
      doWork() { 
       // do things that refer to obj1 and obj2 
      } 
     }; 
    } 
} 

Definición de una clase primera:

void doSomething() { 
    for (/* Assume some loop */) { 
     Object obj1, obj2; 
     IWorker worker = new Worker(obj1, obj2); 
    } 
} 

static class Worker implements IWorker { 
    private Object obj1, obj2; 
    public CustomObject(Object obj1, Object obj2) {/* blah blah */} 

    @Override 
    public void doWork() {} 
}; 

Answer 1

la única diferencia práctica entre las clases anónimas y las clases de nivel superior es que las clases anónimas sostendrán una referencia implícita a la clase externa.

Esto no se manifestará en el rendimiento, pero le afectará si alguna vez serializa estas clases.

Answer 2

Debería haber poca o ninguna diferencia de rendimiento. Si hay una diferencia, estará en un nivel en el que no vale la pena preocuparse.

OMI, usted debe centrarse en la escritura de código que sea legible y fácil de mantener, e ignorar los problemas de rendimiento "micro" hasta que tenga claro evidencia de que son significativos ... basado en el perfil de la aplicación.

(Para el registro, cuando una clase interna anónima se refiere a un final en un ámbito circundante, esto se implementa en el nivel de código de bytes por medio de argumentos de constructor ocultos y instancia oculta atributos. Los bytecodes serán casi el mismo que el códigos de bytes que se obtienen de la otra aplicación.)

Answer 3

Es importante darse cuenta de que las clases anónimas siguen siendo clases conocidas y compiladas por completo en tiempo de compilación. El hecho de que, por ejemplo, esté definiendo un cuerpo de clase anónimo, quizás con muchos métodos y campos, etc. dentro de un bucle, no significa que el tiempo de ejecución tenga que compilar ese tipo en cada iteración.

Por lo tanto, cualquier diferencia en el rendimiento entre los dos enfoques es insignificante. Los factores importantes a considerar son cosas como la legibilidad, la reutilización, la capacidad de prueba, etc.

Answer 4

Especular sobre el rendimiento del código es una excelente manera de perder su tiempo. Nada se compara con comparar realmente el código. Si le preocupa el rendimiento, mida el código. Si sospecha que su código no es óptimo, perfile el código para averiguar dónde se gasta el tiempo, luego intente mejorar esas partes. En este momento, puede ser apropiado estudiar realmente el código de bytes para ver si eso puede darle una pista sobre qué implementación es más eficiente.

Cuando haya hecho eso, mida nuevamente el código para asegurarse de que no empeorará las cosas, por ejemplo, haciendo el código más feo y más difícil de mantener.

Answer 5

De hecho, he notado un impacto significativo en el rendimiento al crear instancias de muchas instancias de una clase anónima.

Pensando si podría deberse a que la clase local es estática lo eliminé y no hizo ninguna diferencia.

En mi caso, estaba haciendo algo 1000 elijo 3 veces, que es 499,500. La versión con la clase local (independientemente de la estática o no) tomó 26 segundos y la versión con la clase anónima funcionalmente idéntica tomó 2 minutos y 20 segundos.

Answer 6

En cuanto al rendimiento, debe considerar si se debe crear o no una clase interna.

Un ejemplo de mala práctica es algo así como:

public List<String> someMethod() { 
     return new ArrayList<String>() {{ 
         add("Item one"); 
         add("Item two"); 
       }}; 
} 

Si bien esta comodidad sintáctica parece inteligente, a primera vista, este (a menudo sin darse cuenta) crea una clase interna anónima cuyo objeto mantiene una referencia a la instancia externa . Como este objeto también se da al exterior como el valor de resultado de someMethod, no puede estar seguro de lo que su interlocutor hace con esta lista. Si pone la instancia ArrayList resultante en alguna variable estática, su Objeto actual también se mantendrá para siempre.