Prestazioni di Java Enums?

Question

Sto implementando un gioco per 2 giocatori che verrà eseguito in un loop stretto letteralmente centinaia di migliaia di volte, essendo quindi di primaria importanza per le prestazioni.

mio codice è in realtà qualcosa di simile:

public class Table { 
    private final int WHITE_PLAYER = +1; 
    private final int BLACK_PLAYER = -1; 

    private final int currentPlayer; 
    private final int otherPlayer; 

    ... 
} 

mi chiedevo se avrei avuto alcun calo di prestazioni dovrei scegliere di sostituire

private final int WHITE_PLAYER = +1; 
private final int BLACK_PLAYER = -1; 

ad un enum definito come

public enum Players { 
    WhitePlayer, 
    BlackPlayer 
} 

Ho avuto l'idea che le enumerazioni fossero solo zucchero sintattico rispetto alle costanti intere e che glaze guarda oltre il bytecode generato per un enum di test, così come il codice che lo chiama, sembra indicare che usarli è in effetti lo stesso che effettuare una chiamata di metodo statico ma per qualche infrastruttura enum che viene configurata al primo avvio.

La mia ipotesi è che sia effettivamente lo stesso utilizzare le enumerazioni come costanti statiche corrette o mi manca qualcosa qui?

Answer 1

In un micro-benchmark, sì, controllare l'uguaglianza costante integer sarà più veloce del controllo dell'uguaglianza costante di enum.

Tuttavia, in un'applicazione reale, per non parlare di un gioco, questo sarà totalmente irrilevante. Le cose che accadono nel sottosistema AWT (o in qualsiasi altro toolkit della GUI) rendono minime queste considerazioni sulla micro-prestazione di molti ordini di grandezza.

EDIT

Vorrei esporre un po 'allora.

Un confronto enumerazione così:

aload_0 
getstatic 
if_acmpne 

Un confronto intero per un piccolo intero così:

iload_0 
iconst_1 
if_icmpne 

Ovviamente, il primo è più lavoro rispetto al secondo, anche se la differenza è abbastanza piccolo

eseguire il seguente test case:

class Test { 

    static final int ONE = 1; 
    static final int TWO = 2; 

    enum TestEnum {ONE, TWO} 

    public static void main(String[] args) { 
     testEnum(); 
     testInteger(); 
     time("enum", new Runnable() { 
      public void run() { 
       testEnum(); 

      } 
     }); 
     time("integer", new Runnable() { 
      public void run() { 
       testInteger(); 
      } 
     }); 
    } 

    private static void testEnum() { 
     TestEnum value = TestEnum.ONE; 
     for (int i = 0; i < 1000000000; i++) { 
      if (value == TestEnum.TWO) { 
       System.err.println("impossible"); 
      } 
     } 
    } 

    private static void testInteger() { 
     int value = ONE; 
     for (int i = 0; i < 1000000000; i++) { 
      if (value == TWO) { 
       System.err.println("impossible"); 
      } 
     } 
    } 

    private static void time(String name, Runnable runnable) { 
     long startTime = System.currentTimeMillis(); 
     runnable.run(); 
     System.err.println(name + ": " + (System.currentTimeMillis() - startTime) + " ms"); 
    } 
} 

e vi accorgerete che il confronto enum è più lento che il confronto intero, sulla mia macchina di circa l'1,5%.

Tutto quello che stavo dicendo è che questa differenza non ha importanza in un'applicazione reale ("L'ottimizzazione prematura è la radice di tutto il male"). Mi occupo di problemi prestazionali su base professionale (vedi il mio profilo) e non ho mai visto un punto caldo che possa essere ricondotto a qualcosa di simile.

Answer 2

È necessario disporre di un codice piacevole e leggibile prima che si interessi alle prestazioni. Fino a quando i risultati del profilo (nessuna supposizione!) Dimostrano che le enumerazioni sono il collo di bottiglia, dimenticano le prestazioni e utilizzano tutto ciò che è più facile da capire.

Answer 3

JIT sarà ottimizzare un sacco di cose che fanno cose come questa irrilevante dopo che è stato in esecuzione per un po '

per non parlare enumerazioni sono più leggibili e più infallibile si dovrebbe fare un errore nel codice

Answer 4

tuo l'ipotesi è corretta Java si assicura che ci sia sempre un'istanza dell'enumerazione in modo che == sia efficiente come confrontare gli interi.