Compilazione JIT e compilazione a livelli
Scopra come la JVM interpreta e poi compila con JIT i metodi più utilizzati e come attivare e osservare la compilazione.
Compilazione JIT e compilazione a livelli è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.
Interprete e JIT
Inizialmente la JVM interpreta il bytecode. Quando un metodo viene chiamato frequentemente («caldo»), il compilatore JIT lo compila in codice macchina nativo, ottenendo un'esecuzione molto più rapida.
Compilazione a livelli (predefinita da Java 8)
La compilazione a livelli utilizza cinque livelli: T0 (interprete), T1 (C1 semplice), T2 (profilazione C1 limitata), T3 (profilazione C1 completa), T4 (C2 completamente ottimizzato). I metodi avanzano di livello man mano che diventano più «caldi».
// Enable/disable tiered compilation:
// -XX:+TieredCompilation (default ON in Java 8+)
// -XX:-TieredCompilation (disables — only C2 used)Compilatore C1 (compilatore client)
C1 compila rapidamente applicando un livello moderato di ottimizzazione. Aggiunge strumentazione per la profilazione, così da misurare la frequenza delle chiamate e gli esiti dei rami per C2.
Compilatore C2 (compilatore server)
C2 (Opto) esegue ottimizzazioni approfondite: inlining, escape analysis, srotolamento dei cicli, vettorializzazione ed eliminazione del codice morto. Produce il codice nativo più veloce, ma richiede più tempo per la compilazione.
// Force server JIT only:
java -server MyApp
// Or explicitly:
java -XX:-TieredCompilation MyApp // uses C2 only (warm-up is slower)Soglia di hot spot
Un metodo viene compilato dal JIT dopo aver superato una soglia del contatore delle invocazioni. Valore predefinito: 10.000 chiamate (C2). È possibile modificarlo con -XX:CompileThreshold=N.
// Lower threshold for faster warm-up (at cost of less optimization):
java -XX:CompileThreshold=1000 MyAppInlining
L'inlining è l'ottimizzazione più incisiva di C2: i metodi piccoli chiamati dal codice caldo vengono «copiati e incollati» nel punto della chiamata, eliminando l'overhead della distribuzione dei metodi e consentendo ulteriori ottimizzazioni.
// Check inlining decisions:
java -XX:+PrintInlining -XX:+UnlockDiagnosticVMOptions MyApp
// Output:
// @ 5 com.example.User::getName (5 bytes) inlinedEscape analysis
Se C2 stabilisce che un oggetto non esce mai dal metodo corrente (o dal thread), può allocarlo sullo stack invece che sull'heap, eliminando completamente la pressione sul GC.
// Objects that don't escape are stack-allocated:
String result = new StringBuilder().append("Hello ").append(name).toString();
// The StringBuilder may be eliminated by escape analysisLog della compilazione JIT
Utilizzi -XX:+PrintCompilation per registrare ogni metodo nel momento in cui viene compilato. L'output mostra il nome del metodo, il livello e i flag di compilazione.
// java -XX:+PrintCompilation MyApp
// Output:
// 1 n java.lang.String::hashCode (0 bytes)
// 25 3 com.example.UserService::findById (42 bytes)
// 31 4 com.example.UserService::findById (42 bytes) made not entrantDeottimizzazione
Se un'ipotesi del JIT viene violata (ad esempio, viene caricata una classe che modifica il tipo del ricevitore di un call site), C2 esegue una «deottimizzazione»: torna all'interprete o a C1. È un comportamento normale e generalmente trasparente.
Tempo di riscaldamento
La compilazione JIT richiede tempo. Nei processi di breve durata, i metodi potrebbero non essere mai compilati dal JIT. Utilizzi la compilazione ahead-of-time (GraalVM Native Image) oppure metta in cache i risultati del JIT con Class Data Sharing (CDS) per velocizzare l'avvio.
// Enable AppCDS to cache JIT-compilable classes:
java -XX:ArchiveClassesAtExit=app.jsa -cp app.jar MyApp # generate archive
java -XX:SharedArchiveFile=app.jsa -cp app.jar MyApp # use archiveJIT di GraalVM
GraalVM sostituisce C2 con un JIT scritto in Java. Consente ottimizzazioni migliori, la possibilità di usare il JIT per linguaggi non Java ed è la base di Native Image (compilazione ahead-of-time).
Verifica rapida
Qual è la tecnica di compilazione JIT che elimina l'overhead delle chiamate ai metodi integrando i metodi piccoli nel chiamante?
Riepilogo
La compilazione a livelli fa avanzare i metodi da C1 (compilazione rapida e profilazione) a C2 (ottimizzazione approfondita). Ottimizzazioni principali: inlining, escape analysis e srotolamento dei cicli. Utilizzi -XX:+PrintCompilation per osservare le decisioni del JIT. Esegua il riscaldamento prima del benchmarking.
Domande Frequenti
La lezione «Compilazione JIT e compilazione a livelli» è gratuita?
Sì — il testo completo di «Compilazione JIT e compilazione a livelli» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.
Cosa imparerò in «Compilazione JIT e compilazione a livelli»?
Scopra come la JVM interpreta e poi compila con JIT i metodi più utilizzati e come attivare e osservare la compilazione. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Java Academy?
Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Compilazione JIT e compilazione a livelli»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Java Academy?
Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Fasi del caricamento delle classi: load, link, initialize
- Gerarchia dei ClassLoader e loader personalizzati
- Ispezionare il bytecode con javap
- Compilazione JIT e compilazione a livelli