Prestazioni di nuovo operatore rispetto a newInstance() in Java

Question

Stavo usando newInstance() in un'area del mio codice di importanza critica per le prestazioni. La firma del metodo è:

<T extends SomethingElse> T create(Class<T> clasz)

mi passano Something.class come argomento, ottengo un'istanza di SomethingElse, creata con newInstance().

Oggi sono tornato per cancellare questa prestazione TODO dall'elenco, quindi ho eseguito un paio di test dell'operatore new rispetto a newInstance(). Sono rimasto molto sorpreso dalla penalizzazione delle prestazioni di newInstance().

ho scritto un po 'su di esso, qui: http://biasedbit.com/new-vs-newinstance/

(. Ci scusiamo per la promozione di auto ... mi piacerebbe inserire il testo qui, ma a questa domanda sarebbe cresciuto di proporzioni)

Cosa Mi piacerebbe sapere perché il flag -server fornisce un tale aumento di prestazioni quando il numero di oggetti creati cresce in gran parte e non per valori "bassi", ad esempio 100 o 1000.

Ho imparato la lezione con tutta la cosa dei riflessi, questa è solo una curiosità per le ottimizzazioni che la JVM esegue in runtime, in particolare con il flag -server. Inoltre, se sto facendo qualcosa di sbagliato nel test, apprezzerei il tuo feedback!

---

Modifica: ho aggiunto una fase di riscaldamento e ora i risultati sono più stabili. Grazie per l'input!

Answer 1

Ho imparato la lezione con l'intera cosa dei riflessi, questa è solo una curiosità sulle ottimizzazioni eseguite da JVM in runtime, specialmente con il flag -server. Inoltre, se sto facendo qualcosa di sbagliato nel test, apprezzerei il tuo feedback!

Rispondendo per prima alla seconda parte, il codice sembra commettere l'errore classico per i micro-benchmark Java e non "riscaldare" la JVM prima di effettuare le misurazioni. L'applicazione deve eseguire il metodo che esegue il test alcune volte, ignorando le prime iterazioni ... almeno finché i numeri non si stabilizzano. La ragione di ciò è che una JVM deve fare molto lavoro per avviare un'applicazione; per esempio. caricamento delle classi e (quando sono state eseguite alcune volte) JIT che compila i metodi in cui viene impiegato un tempo significativo per l'applicazione.

Penso che la ragione per cui "-server" sta facendo la differenza è che (tra le altre cose) cambia le regole che determinano quando compilare JIT. Il presupposto è che per un "server" è meglio JIT prima questo dà avvio più lento ma una maggiore velocità effettiva. (Al contrario, un "client" è sintonizzato per posticipare la compilazione JIT in modo che l'utente ottenga prima una GUI funzionante.)

Answer 2

Tra le altre cose, il profilo di garbage collection per l'opzione -server ha valori predefiniti survivor space sizing significativamente diversi.

A una lettura più ravvicinata, vedo che il tuo esempio è un micro-benchmark ei risultati potrebbero essere contro-intuitivi. Ad esempio, sulla mia piattaforma, le chiamate ripetute a newInstance() vengono efficacemente ottimizzate durante le ripetute corse, rendendo newInstance() visualizzato 12,5 volte più veloce di new.

Answer 3

IMHO la penalizzazione delle prestazioni deriva dal meccanismo di caricamento della classe. In caso di riflessione vengono utilizzati tutti i meccanismi di sicurezza e quindi la penalità di creazione è maggiore. In caso di nuovo operatore le classi sono già caricate nella VM (verificate e preparate dal classloader predefinito) e l'istanziazione effettiva è un processo economico. Il parametro -server esegue molte ottimizzazioni JIT per il codice utilizzato di frequente. Potresti volerlo provare anche con il parametro -batch che cambierà il tempo di avvio ma poi il codice verrà eseguito più velocemente.