Java Academy · Lektion

JIT-kompilering och nivåindelad kompilering

Lär er hur JVM tolkar och sedan JIT-kompilerar heta metoder samt hur ni utlöser och observerar kompileringen.

Lektion 4 av 413 steg

JIT-kompilering och nivåindelad kompilering är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

Tolkning kontra JIT

JVM tolkar inledningsvis bytekod. När en metod anropas ofta (den blir ”het”) kompilerar JIT-kompilatorn den till inbyggd maskinkod för mycket snabbare körning.

Nivåindelad kompilering (standard sedan Java 8)

Nivåindelad kompilering använder fem nivåer: T0 (tolk), T1 (enkel C1), T2 (begränsad profilering med C1), T3 (full profilering med C1), T4 (fullt optimerad C2). Metoder flyttas upp genom nivåerna när de blir hetare.

// Enable/disable tiered compilation:
// -XX:+TieredCompilation   (default ON in Java 8+)
// -XX:-TieredCompilation   (disables — only C2 used)

C1-kompilatorn (klientkompilatorn)

C1 kompilerar snabbt med måttliga optimeringar. Den lägger till profileringsinstrumentering för att mäta anropsfrekvenser och grenutfall åt C2.

C2-kompilatorn (serverkompilatorn)

C2 (Opto) utför djupgående optimeringar: inlining, escape-analys, looputrullning, vektorisering och eliminering av död kod. Den producerar den snabbaste inbyggda koden men tar längre tid att kompilera.

// Force server JIT only:
java -server MyApp
// Or explicitly:
java -XX:-TieredCompilation MyApp   // uses C2 only (warm-up is slower)

Hotspot-tröskel

En metod JIT-kompileras efter att ha passerat en tröskel för anropsräknaren. Standardvärde: 10 000 anrop (C2). Ställ in med -XX:CompileThreshold=N.

// Lower threshold for faster warm-up (at cost of less optimization):
java -XX:CompileThreshold=1000 MyApp

Inlining

Inlining är C2:s mest betydelsefulla optimering: små metoder som anropas från het kod kopieras in på anropsplatsen, vilket eliminerar kostnaden för metoddispatch och möjliggör ytterligare optimeringar.

// Check inlining decisions:
java -XX:+PrintInlining -XX:+UnlockDiagnosticVMOptions MyApp
// Output:
// @ 5  com.example.User::getName (5 bytes)   inlined

Escape-analys

Om C2 fastställer att ett objekt aldrig lämnar den aktuella metoden (eller tråden) kan den allokera det på stacken i stället för heapen – och därmed helt eliminera belastningen på 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 analysis

JIT-kompileringsloggar

Använd -XX:+PrintCompilation för att logga varje metod när den kompileras. Utdata visar metodnamn, nivå och kompileringsflaggor.

// 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 entrant

Deoptimering

Om ett JIT-antagande bryts (till exempel om en klass laddas in som ändrar mottagartypen vid en anropspunkt) deoptimerar C2 – den återgår till tolken eller C1. Detta är normalt och vanligtvis transparent.

Uppvärmningstid

JIT-kompilering tar tid. I kortlivade processer kanske metoder aldrig JIT-kompileras. Använd förhandskompilering (GraalVM Native Image) eller cachelagra JIT-resultat med Class Data Sharing (CDS) för snabbare uppstart.

// 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 archive

GraalVM JIT

GraalVM ersätter C2 med en JIT-kompilator skriven i Java. Det möjliggör bättre optimeringar, möjlighet att använda JIT för andra språk än Java och utgör grunden för Native Image (förhandskompilering).

Snabbkontroll

Vilken JIT-kompileringsteknik eliminerar kostnaden för metodanrop genom att slå samman små metoder med den anropande metoden?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Nivåindelad kompilering flyttar metoder från C1 (snabb kompilering, profilering) till C2 (djupgående optimering). Viktiga optimeringar: inlining, escape-analys och looputrullning. Använd -XX:+PrintCompilation för att observera JIT-beslut. Värm upp innan benchmarking.

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 104
Lektioner: 374

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”JIT-kompilering och nivåindelad kompilering” gratis?

Ja – hela texten till ”JIT-kompilering och nivåindelad kompilering” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”JIT-kompilering och nivåindelad kompilering”?

Lär er hur JVM tolkar och sedan JIT-kompilerar heta metoder samt hur ni utlöser och observerar kompileringen. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”JIT-kompilering och nivåindelad kompilering”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Faser vid klassinläsning: Load, Link, Initialize
ClassLoader-hierarki och egna laddare
Inspektera bytekod med javap
JIT-kompilering och nivåindelad kompilering

← Tillbaka till Java Academy