Platformthreads versus virtuele threads
Wanneer elk type geschikt is
Platformthreads versus virtuele threads is een gratis Java Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Java Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Java Academy bevat in totaal 4 lessen.
Twee soorten threads
Java heeft nu twee soorten threads. Platformthreads zijn de klassieke omhulsels rond threads van het besturingssysteem. Virtuele threads zijn lichtgewicht en worden door de JVM beheerd.
Weten wanneer je welke gebruikt, vormt de kern van het schrijven van schaalbare gelijktijdige Java-code.
Een platformthread maken
Je maakt een platformthread met Thread.ofPlatform(), de tegenhanger van Thread.ofVirtual().
public class Main {
public static void main(String[] args) throws InterruptedException {
Thread p = Thread.ofPlatform().name("native-worker").start(() ->
System.out.println("Platform? " + !Thread.currentThread().isVirtual()));
p.join();
}
}Kosten vergelijken
Platformthreads zijn zwaar:
- Ongeveer 1 MB gereserveerde stack per thread
- Langzaam te maken
- Beperkt tot enkele duizenden
Virtuele threads zijn goedkoop: een kleine aanvankelijke stack, snel te maken en aantallen van miljoenen zijn haalbaar.
I/O-gebonden werk
Als je taak het grootste deel van de tijd wacht op het netwerk, een schijf of een database, leveren virtuele threads grote voordelen op.
Terwijl één virtuele thread blokkeert, komt zijn draagthread vrij om andere threads uit te voeren. Zo kunnen een handvol threads van het besturingssysteem duizenden aanvragen verwerken.
CPU-gebonden werk
Voor pure berekeningen die nooit blokkeren, leveren virtuele threads geen snelheidswinst op. Je wordt beperkt door het aantal processorkernen.
Hier is een vaste pool met een omvang die op het aantal processors is afgestemd het juiste hulpmiddel.
import java.util.concurrent.*;
public class Main {
public static void main(String[] args) throws Exception {
int cores = Runtime.getRuntime().availableProcessors();
try (ExecutorService cpu = Executors.newFixedThreadPool(cores)) {
Future<Long> f = cpu.submit(() -> {
long s = 0;
for (long i = 0; i < 1_000_000L; i++) s += i;
return s;
});
System.out.println("Cores: " + cores + ", sum: " + f.get());
}
}
}Blokkeren simuleren
Dit fragment laat zien hoe veel virtuele threads gelijktijdig slapen, als vervanging voor blokkerende I/O. Probeer je voor te stellen dat 10.000 platformthreads hetzelfde doen.
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
public class Main {
public static void main(String[] args) {
AtomicInteger done = new AtomicInteger();
try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
for (int i = 0; i < 10_000; i++) {
exec.submit(() -> {
try { Thread.sleep(50); } catch (InterruptedException e) {}
done.incrementAndGet();
});
}
}
System.out.println("Finished blocking tasks: " + done.get());
}
}Daemonstatus
Virtuele threads zijn altijd daemon-threads en kunnen niet worden ingesteld als niet-daemonthreads. Platformthreads nemen standaard de daemonstatus van hun maker over, maar die status kan expliciet worden ingesteld.
public class Main {
public static void main(String[] args) throws InterruptedException {
Thread v = Thread.ofVirtual().unstarted(() -> {});
Thread p = Thread.ofPlatform().unstarted(() -> {});
System.out.println("virtual daemon: " + v.isDaemon());
System.out.println("platform daemon: " + p.isDaemon());
}
}Prioriteiten worden genegeerd
Virtuele threads rapporteren altijd een prioriteit van NORM_PRIORITY, en het instellen van de prioriteit heeft geen effect. De JVM verzorgt de planning, niet de planner van het besturingssysteem.
public class Main {
public static void main(String[] args) {
Thread v = Thread.ofVirtual().unstarted(() -> {});
v.setPriority(Thread.MAX_PRIORITY);
System.out.println("Priority is still: " + v.getPriority());
}
}Richtlijn voor je keuze
Een praktische vuistregel:
- Veel taken die op I/O wachten? Gebruik virtuele threads.
- Zware berekeningen die door de CPU worden beperkt? Gebruik een vaste pool met platformthreads.
- Heb je threadafstemming op besturingssysteemniveau nodig, zoals prioriteit of affiniteit? Gebruik platformthreads.
Ze bestaan naast elkaar
Je hoeft niet voor het hele programma één soort te kiezen. Een typische toepassing gebruikt virtuele threads voor het afhandelen van aanvragen en een kleine pool met platformthreads voor CPU-intensieve onderdelen.
Beide delen dezelfde Thread-API, dus je kunt ze probleemloos combineren.
Tip voor migratie
Bij het migreren van een I/O-zware service is het vervangen van de executor de kleinste wijziging: vervang een vaste pool of cachepool door newVirtualThreadPerTaskExecutor().
Let wel op vastzetten en misbruik van ThreadLocal; dat behandelen we in de volgende les.
Korte controle
Kies de werklast waarbij virtuele threads het duidelijkste voordeel bieden.
Samenvatting
Je hebt de twee threadmodellen vergeleken:
- Platformthreads: zwaar, gebaseerd op het besturingssysteem en het best geschikt voor CPU-gebonden werk en afstemming op besturingssysteemniveau
- Virtuele threads: goedkoop, door de JVM beheerd, altijd daemon en het best geschikt voor I/O-gebonden gelijktijdigheid
- Ze bestaan naast elkaar en delen dezelfde API
Hierna: de valkuilen van vastzetten en ThreadLocals.
Leer Java met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 104
- Lessen
- 374
Veelgestelde vragen
Is de les “Platformthreads versus virtuele threads” gratis?
Ja — de volledige tekst van “Platformthreads versus virtuele threads” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Java Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Java Academy bevat in totaal 4 lessen.
Wat leer ik in “Platformthreads versus virtuele threads”?
Wanneer elk type geschikt is Je oefent met Java Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Java Academy te beginnen?
Ervaring vooraf is niet nodig. Java Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “Platformthreads versus virtuele threads”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Java Academy?
Ja. Elke les over Java Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Wat zijn virtuele threads
- Virtuele threads maken
- Platformthreads versus virtuele threads
- Valkuilen: pinning en ThreadLocals