JIT: essentie, Just-In-Time-compilatie en hoe het werkt
JIT (Just-In-Time) — technologie voor dynamische compilatie die bytecode of tussenliggende programmarepresentatie omzet in machine-instructies, direct tijdens uitvoering. In Android verscheen de JIT-compiler voor het eerst in versie 2.2 Froyo als onderdeel van de Dalvik virtuele machine en versnelde applicaties 2–5 keer. Volgens Google, 2024, combineert moderne JIT in ART interpretatie met geprofileerde compilatie van hot-methoden.
Belangrijkste punten
- JIT — Just-In-Time-compilatie: omzetting van code in machinecode direct tijdens programma-uitvoering.
- In Dalvik compileerde JIT hot-methoden na overschrijding van de aanroeppraal (~200 keer).
- JIT verkort installatietijd en neemt minder ruimte in dan volledige AOT-compilatie.
- Belangrijkste nadeel — opwarmvertraging: eerste seconden werkt de app langzamer.
- In moderne ART wordt JIT gebruikt in hybride modus met AOT-optimalisatie op de achtergrond.
Wat is JIT-compilatie?
Just-In-Time (JIT) — compilatiemethode waarbij broncode of bytecode niet van tevoren (zoals bij AOT), maar op het moment van de eerste aanroep van het betreffende programmadeel wordt omgezet in machine-instructies. De term „Just-In-Time” betekent dat compilatie „op het juiste moment” plaatsvindt — direct voor uitvoering.
Het concept JIT bestaat sinds de jaren 1960, maar kreeg brede verspreiding met de komst van Java Virtual Machine in 1995. JIT maakt het mogelijk om de overdraagbaarheid van bytecode (één keer schrijven — overal uitvoeren) te combineren met prestaties die bijna aan native code liggen. In Java HotSpot VM analyseert de JIT-compiler uitgevoerde code en compileert alleen de meest kritieke delen, wat tijd en geheugen bespaart.
Werkingsprincipe
De JIT-compiler ontvangt bytecode, interpreteert deze en verzamelt parallel statistieken. Wanneer een bepaald codegedeelte (methode, lus) vaak genoeg wordt aangeroepen, besluit JIT tot compilatie. Gecompileerde machinecode wordt in de cache opgeslagen — bij herhaalde aanroepen wordt de reeds gereed zijnde versie gebruikt. Dit zorgt voor versnelling zonder dat het hele programma gecompileerd hoeft te worden.
java
// Voorbeeld: methode wordt hot na meerdere aanroepen
public class HotMethod {
private int compute(int n) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += i * i;
}
return sum;
}
}
// 500 keer aanroepen in lus — JIT compileert compute
for (int t = 0; t < 500; t++) {
hot.compute(1000);
}JIT in Android: Dalvik en ART
In Android heeft JIT-compilatie drie evolutiefasen doorgemaakt. Eerste fase — Dalvik zonder JIT (Android 1.0–2.1): pure interpretatie van DEX-bytecode. Tweede fase — Dalvik met JIT (Android 2.2–4.4): verschijnen van de JIT-compiler die applicaties 2–5 keer versnelde. Derde fase — ART met hybride JIT (Android 7.0+): terugkeer van JIT in een nieuwe hoedanigheid.
JIT in Dalvik was geïmplementeerd als een trace-based compiler. Het analyseerde niet afzonderlijke methoden, maar reeksen instructies (traces) die vaak sequentieel worden uitgevoerd. Dit maakte compilatie van volledige uitvoeringspaden mogelijk, inclusief meerdere methoden. Deze benadering was efficiënt voor mobiele processoren met een kleine instructiecache, omdat de gecompileerde trace in de L1-cache paste.
JIT in moderne ART
Vanaf Android 7.0 Nougat gebruikt ART method-based JIT — compileert afzonderlijke methoden op basis van uitvoeringsprofielen. Deze JIT werkt aanzienlijk sneller dan Dalvik JIT: typische compilatietijd van één methode is 0.5–1 ms versus 3–5 ms in Dalvik. Gecompileerde code wordt opgeslagen in een apart geheugengebied (JIT code cache), niet in de heap van de applicatie, wat fragmentatie vermindert.
| Parameter | Dalvik JIT | ART JIT |
|---|---|---|
| Type | Trace-based | Method-based |
| Compilatiesnelheid | 3–5 ms/methode | 0.5–1 ms/methode |
| Compilatiedrempel | ~200 aanroepen | Dynamisch |
| Codecache | In applicatie-heap | JIT code cache |
| Profilering | Intern | Externe .prof-bestanden |
Detectie van hot-methoden en compilatiedrempels
Het centrale mechanisme van JIT — detectie van hot-methoden. Elke methodeaanroep verhoogt een interne teller. Wanneer de teller de drempel overschrijdt, wordt de methode gemarkeerd als „heet” en naar compilatie gestuurd. In Dalvik was de drempel vast ingesteld (~200 aanroepen). In ART worden de tellers dynamisch aangepast aan de beschikbare bronnen van het apparaat.
Het compilatieproces omvat verschillende fasen. Eerste — bytecode-analyse: JIT bestudeert de instructiestroom en bouwt een dataflow-graaf (data-flow graph). Tweede — optimalisatie: inlinen van kleine methoden, verwijderen van dode code, constant folding. Derde — codegeneratie: omzetting van de geoptimaliseerde graaf in machine-instructies voor de specifieke CPU-architectuur (ARM, ARM64, x86).
java
// Demonstratie van inlining — JIT vervangt methodebody
public int inlineExample() {
return square(5);
}
private int square(int x) {
return x * x;
} // JIT vervangt aanroep door return 5 * 5;OSR — On-Stack Replacement
Een speciale techniek van JIT — On-Stack Replacement (OSR). Als een methode een lange lus bevat die honderden iteraties duurt, kan JIT de lus „in de vlucht” compileren en de geïnterpreteerde versie direct tijdens uitvoering vervangen door de gecompileerde versie. OSR is bijzonder effectief voor rekentaken: rendering, beeldverwerking, cryptografie.
JIT vs AOT: vergelijkende analyse
JIT en AOT — twee benaderingen van compilatie met tegengestelde compromissen. JIT offert snelheid van de eerste start op voor compactheid van distributie en aanpassingsvermogen. AOT offert installatietijd en schijfruimte op voor maximale prestaties vanaf de eerste seconde. Geen van beide benaderingen is absoluut beter — de keuze hangt af van het scenario.
Het belangrijkste voordeel van JIT is adaptieve optimalisatie. JIT kan profielinformatie gebruiken die niet beschikbaar is voor AOT: exacte objecttypen, werkelijke aanroepfrequentie, feitelijke vertakkingen. Dit maakt agressieve optimalisaties mogelijk die onmogelijk zijn bij statische compilatie. Bijvoorbeeld, JIT kan methodeaanroepen virtualiseren (devirtualize) als in de praktijk slechts één ontvangertype voorkomt.
| Criterium | JIT | AOT |
|---|---|---|
| Installatietijd | Onmiddellijk | Afhankelijk van grootte |
| Eerste start | Langzamer (opwarmen) | Snel |
| Schijfruimte | Minimaal | +15–30% |
| Aanpassingsvermogen | Hoog | Laag |
| CPU-verbruik | Pieken bij compilatie | Stabiel |
Wanneer JIT kiezen
JIT-compilatie heeft de voorkeur wanneer snelheid van implementatie en besparing van schijfruimte belangrijk zijn. In de context van mobiele ontwikkeling is JIT ideaal voor applicaties die vaak worden bijgewerkt (A/B-testen, hotfix). JIT is ook handig in de ontwikkelingsfase, wanneer code tientallen keren per dag opnieuw wordt gebouwd — elke bespaarde seconde bij compilatie versnelt de feedbackcyclus.
Voordelen van JIT-compilatie
JIT biedt ontwikkelaars een aantal praktische voordelen. Eerste — kleine APK-grootte. Bij de JIT-benadering wordt in de APK alleen bytecode (DEX) verpakt, die 20–30% minder ruimte inneemt dan gecompileerde native code. Voor gebruikers met beperkte ingebouwde opslag is dit een significant voordeel.
Tweede voordeel — aanpassing aan het apparaat. JIT compileert code rekening houdend met de werkelijke CPU-architectuur, hoeveelheid RAM en huidige belasting. Op een apparaat met 2 GB RAM kan JIT bijvoorbeeld minder agressief compilen om geheugen te besparen, en op een vlaggenschip met 12 GB alle mogelijke optimalisaties toepassen. AOT-compilatie daarentegen legt de beslissing vast op het moment van installatie.
Platformonafhankelijkheid
Bytecode blijft platformonafhankelijk, wat de distributie van applicaties vereenvoudigt. Één APK werkt op ARM-, ARM64- en x86-apparaten, en JIT zorgt voor generatie van native code voor elke architectuur. Voor de AOT-benadering zou men ofwel meerdere varianten van native code in de APK moeten opnemen (grotere omvang), of een aparte versie voor elke architectuur moeten compileren.
Nadelen en beperkingen van JIT
Het grootste nadeel van JIT is opwarmvertraging (warm-up delay). De gebruiker ziet vertragingen in de eerste seconden van de applicatie, terwijl JIT hot-methoden compileert. In games uit zich dit als „hakken” (stuttering) in beginniveaus. In applicaties met animaties — haperingen bij eerste overgangen tussen schermen.
Het tweede nadeel is energieverbruik. Het compilatieproces belast de CPU intensief, waardoor het energieverbruik met 10–20% toeneemt tijdens de opwarmperiode. Op batterijgevoede apparaten verkort dit de gebruiksduur. Vooral merkbaar in scenario's met frequente herstarts van applicaties (multitasking met beperkt geheugen, waarbij het systeem processen verwijdert en opnieuw laadt).
Cachefragmentatie
Een ander probleem is fragmentatie van de JIT-cache. Gecompileerde code wordt opgeslagen in een aaneengesloten geheugengebied. Bij het laden van nieuwe klassen en compilatie van extra methoden raakt de cache gefragmenteerd, wat de overhead van geheugenbeheer verhoogt. In Dalvik werd dit probleem opgelost door periodieke cache-opschoning; in ART wordt de JIT-cache apart van de heap toegewezen en gebruikt het een eigen defragmentatiestrategie.
Hybride modus: het beste van twee werelden
De moderne benadering in ART — hybride compilatie, die de sterke punten van JIT en AOT combineert. Bij de installatie van de applicatie wordt geen compilatie uitgevoerd — alleen verificatie van de bytecode (verify). Dit zorgt voor snelle installatie en minimale ruimte-inname. Eerste starts werken in interpretatiemodus met JIT-compilatie van hot-methoden — de gebruiker krijgt acceptabele prestaties zonder lang wachten.
Parallel werkt de achtergrondprofiler, die gegevens verzamelt over werkelijk gebruik. Na 2–3 volledige starts van de applicatie bereikt het profiel voldoende volledigheid en start het systeem dex2oat om hot-methoden naar native code te compileren. Deze bewerking wordt op de achtergrond uitgevoerd wanneer het apparaat niet wordt belast (opladen, scherm uit). Na voltooiing van de AOT op de achtergrond krijgt de applicatie prestaties vergelijkbaar met volledige AOT-compilatie.
bash
# Geforceerde start van achtergrondcompilatie
adb shell cmd package compile -m speed-profile -f com.example.app
# Compilatiestatus bekijken
adb shell cmd package dump-profiles com.example.appResultaten van de hybride benadering
Volgens Google I/O 2017 verkortte hybride compilatie de installatietijd van applicaties met 30–50% vergeleken met pure AOT. De ingenomen ruimte op de systeempartitie nam af met 20–30%. De prestaties na achtergrondcompilatie komen overeen met het niveau van volledige AOT. Het enige scenario waarin de hybride onderdoet voor AOT is de eerste start direct na installatie: de applicatie werkt in JIT-modus en kan 10–15% langzamer zijn.
Veelgestelde vragen
Wat is JIT-compilatie in eenvoudige woorden?
JIT — een manier om een programma te versnellen waarbij code niet van tevoren, maar in delen tijdens het werk naar machinetaal wordt vertaald. De meest gebruikte delen worden gecompileerd en gecachet, zeldzame delen blijven in hun oorspronkelijke vorm.
Waarin verschilt JIT van AOT?
JIT compileert code tijdens uitvoering, wat ruimte bespaart en installatie versnelt. AOT compileert alle code van tevoren — de applicatie start sneller, maar vereist meer schijfruimte en installatietijd.
Waarom is JIT uit Android verwijderd?
JIT is niet verwijderd, maar geévolueerd. In Android 5.0 werd Dalvik met JIT vervangen door ART met pure AOT. In Android 7.0 keerde JIT terug in ART als onderdeel van een hybride systeem, waar het samenwerkt met AOT-compilatie op de achtergrond voor optimale prestaties.
Hoe beïnvloedt JIT het energieverbruik?
JIT verhoogt het energieverbruik met 10–20% tijdens de opwarmperiode door CPU-belasting. Na voltooiing van compilatie van hot-methoden keert het energieverbruik terug naar normaal. De hybride modus van ART minimaliseert deze pieken dankzij achtergrondcompilatie.
Ziet de gebruiker JIT-opwarming?
Ja, in scenario's met intensieve berekeningen. De gebruiker kan vertragingen opmerken in de eerste seconden van de applicatie of aan het begin van een game. In moderne versies van Android (8.0+) minimaliseert de hybride modus dit effect dankzij geprofileerde compilatie.
Samenvatting
- JIT (Just-In-Time) — dynamische compilatie die bytecode tijdens uitvoering omzet in machine-instructies.
- In Android doorliep JIT een evolutie: trace-based in Dalvik → volledige AOT → JIT+AOT hybride in moderne ART.
- Hot-methoden worden gedetecteerd via aanroeptellers en gecompileerd bij overschrijding van de drempel (~200 aanroepen).
- OSR (On-Stack Replacement) maakt het mogelijk lange lussen in de vlucht te compileren zonder uitvoering te onderbreken.
- Belangrijkste voordelen van JIT: kleine APK-grootte, snelle installatie en aanpassing aan het apparaat.
- Belangrijkste nadelen: opwarmvertraging, piekenergieverbruik en cachefragmentatie.
- Hybride modus ART (Android 7.0+) verkort installatietijd met 30–50% bij behoud van hoge prestaties.
We ontwikkelen een mobiele applicatie turnkey
IT Sectr creëert sinds 2017 iOS- en Android-applicaties voor startups en bedrijven. We adviseren u en stellen de beste oplossing voor.
Lees ook