NoDovrei guardare il bytecode prodotto da un compilatore java?
Yes
Sto chiedendo senza sapere veramente (ovviamente) quindi sentitevi liberi di reindirizzare a collegamenti ipertestuali JIT.
Sì, ma in una certa misura - è buono come un'opportunità educativa per vedere cosa sta succedendo sotto il cofano, ma probabilmente dovrebbe essere fatto con moderazione.
Può essere una buona cosa, come guardare il bytecode può aiutare a capire come il codice sorgente Java verrà compilato in bytecode Java. Inoltre, potrebbe dare alcune idee su quale tipo di ottimizzazioni verranno eseguite dal compilatore e forse alcune limitazioni alla quantità di ottimizzazione che il compilatore può eseguire.
Ad esempio, se viene eseguita una concatenazione di stringhe, javac sarà ottimizzare la concatenazione in utilizzando un StringBuilder ed eseguendo append metodi per concatenare i String s.
Tuttavia, se la concatenazione stringa è eseguita in un ciclo, un nuovo StringBuilder può istanziare ad ogni iterazione, con conseguente possibile deterioramento delle prestazioni rispetto ad istanziare manualmente un StringBuilder fuori del ciclo e solo eseguendo append s all'interno del ciclo.
Sulla questione del JIT. La compilazione just-in-time sarà specifica per l'implementazione JVM, quindi non è molto facile scoprire cosa sta effettivamente accadendo al bytecode quando viene convertito nel codice nativo, e inoltre, non possiamo dire quali parti sono JITted (almeno non senza alcuni strumenti specifici di JVM per vedere che tipo di compilation JIT viene eseguita - non conosco nessun dettaglio specifico in quest'area, quindi sto solo speculando.)
Detto questo, la JVM sta eseguendo comunque il bytecode, il modo in cui viene eseguito è più o meno opaco per lo sviluppatore e, ancora, specifico per JVM. Potrebbero esserci alcuni trucchi delle prestazioni che una JVM esegue mentre un'altra no.
Quando si tratta di osservare il bytecode generato, si tratta di imparare cosa sta effettivamente accadendo al codice sorgente quando viene compilato in bytecode. Essere in grado di vedere i tipi di ottimizzazioni eseguite dal compilatore, ma anche capire che ci sono dei limiti al modo in cui il compilatore può eseguire le ottimizzazioni.
Detto questo, non penso che sia una buona idea diventare ossessionati dalla generazione di bytecode e provare a scrivere programmi che emetteranno il bytecode più ottimizzato. La cosa più importante è scrivere codice sorgente Java che sia leggibile e manutenibile da altri.
Dipende interamente da ciò che stai cercando di fare. Se stai cercando di ottimizzare un metodo/modulo, guardare il codice byte sarà uno spreco di tempo. Cerca sempre il profilo per scoprire dove sono i tuoi colli di bottiglia, quindi ottimizza i colli di bottiglia. Se il collo di bottiglia sembra il più stretto possibile e devi renderlo più veloce, potresti non avere altra scelta che riscriverlo nel codice nativo e nell'interfaccia con JNI.
Cercare di ottimizzare il codice byte generato sarà di scarso aiuto, dal momento che il compilatore JIT farà un sacco di lavoro, e non avrai una gran idea di cosa esattamente stia facendo.
Non ci penso. A parte il fatto di dover eseguire il debug del compilatore javac o di voler sapere come argomento di interesse, non riesco a pensare a una buona ragione per cui a qualcuno interesserebbe sapere quale bytecode viene generato.
Conoscere il bytecode non ti renderà un programmatore Java migliore, più di sapere come funziona un motore a combustione interna che ti renderà un guidatore migliore.
Pensa in termini di astrazioni. Non è necessario conoscere le azioni dei quark o degli atomi quando si tenta di calcolare le orbite dei pianeti. Per essere un buon programmatore Java, dovresti probabilmente imparare ... um .. Java. Sì, Java, il gioco è fatto :-)
A meno che tu non stia sviluppando un server di grande capacità di qualche tipo, probabilmente non avrai mai bisogno di esaminare il bytecode, tranne per curiosità. Il codice sorgente che aderisce a pratiche di codifica accettabili nella tua organizzazione fornirà prestazioni ampie per la maggior parte delle applicazioni.
Non preoccuparti delle prestazioni finché non hai riscontrato problemi dopo aver caricato il test dell'applicazione (o l'intera forza del servizio clienti ti lincia per quella schermata che richiede "per sempre" di caricare). Quindi, martella i colli di bottiglia e lascia il resto del codice da solo.
Il codice byte richiede una curva di apprendimento modesta da comprendere. Certo, non fa mai male imparare di più, ma il pragmatismo suggerisce di rimandarlo fino a quando non è necessario. (E se dovesse venire quel momento, ti consiglio di trovare qualcuno che ti aiuti).
L'esame del bytecode raramente indica le prestazioni. (Eccezione di dove javac sta facendo qualcosa di alto livello - concatenazione di stringhe e boxe). –
Ma Cole Trickle è diventato un autista migliore una volta venuto a conoscenza degli interni dell'auto. – Boune