Java Academy · leksjon

Plattformtråder kontra virtuelle tråder

Når hver av dem passer

Leksjon 3 av 413 trinn

Plattformtråder kontra virtuelle tråder er en gratis leksjon i Java Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Java Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Java Academy inneholder totalt 4 leksjoner.

To typer tråder

Java har nå to trådtyper. Plattformtråder er de klassiske omslagene rundt OS-tråder. Virtuelle tråder er lettvektige og administreres av JVM-en.

Å vite når du bør velge hver av dem, er selve kjernen i å skrive skalerbar samtidig Java-kode.

Opprette en plattformtråd

Du oppretter en plattformtråd med Thread.ofPlatform(), motstykket til 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();
    }
}

Sammenligning av kostnader

Plattformtråder er ressurskrevende:

Omtrent 1 MB reservert stakk per tråd
Treg opprettelse
Begrenset til noen få tusen

Virtuelle tråder er billige: liten innledende stakk, rask opprettelse og mulig å opprette millioner av dem.

I/O-bundet arbeid

Hvis oppgaven bruker mesteparten av tiden på å vente på nettverk, disk eller en database, har virtuelle tråder store fordeler.

Når en virtuell tråd blokkeres, frigjøres bærertråden slik at den kan kjøre andre tråder. Dermed kan noen få OS-tråder betjene tusenvis av forespørsler.

CPU-bundet arbeid

For rene beregninger som aldri blokkeres, gir virtuelle tråder ingen hastighetsøkning. Du er begrenset av antallet kjerner.

Her er en fast pool dimensjonert etter prosessorene det riktige verktøyet.

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());
        }
    }
}

Simulere blokkering

Dette kodeeksempelet viser mange virtuelle tråder som sover samtidig, som en erstatning for blokkerende I/O. Prøv å forestille deg 10 000 plattformtråder som gjør det samme.

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());
    }
}

Daemon-status

Virtuelle tråder er alltid daemon-tråder og kan ikke gjøres til vanlige tråder. Plattformtråder arver som standard oppretterens daemon-status, men denne kan angis eksplisitt.

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());
    }
}

Prioriteter ignoreres

Virtuelle tråder rapporterer alltid en prioritet på NORM_PRIORITY, og det har ingen effekt å angi prioriteten. Planleggingen håndteres av JVM-en, ikke av operativsystemets planlegger.

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());
    }
}

Retningslinje for valg

En praktisk tommelfingerregel:

Mange oppgaver som venter på I/O? Bruk virtuelle tråder.
Tunge beregninger som er begrenset av CPU-en? Bruk en fast pool med plattformtråder.
Trenger du justering på OS-nivå av tråder, for eksempel prioritet eller prosessortilknytning? Bruk plattformtråder.

De eksisterer side om side

Du trenger ikke å velge én type for hele programmet. Et typisk program bruker virtuelle tråder til håndtering av forespørsler og en liten pool med plattformtråder til CPU-intensive deler.

Begge deler bruker det samme Thread-API-et, så det er enkelt å blande dem.

Tips ved migrering

Når du flytter en I/O-tung tjeneste, er den minste endringen å bytte executor: erstatt en fast eller hurtigbufret pool med newVirtualThreadPerTaskExecutor().

Vær bare oppmerksom på pinning og misbruk av ThreadLocal, som omtales i neste leksjon.

Kort kontroll

Velg arbeidsbelastningen der virtuelle tråder gir den tydeligste fordelen.

Besvar den i den interaktive leksjonen

Oppsummering

Du har sammenlignet de to trådmodellene:

Plattformtråder: ressurskrevende, støttet av operativsystemet og best for CPU-bundet arbeid og justering på OS-nivå
Virtuelle tråder: billige, administrert av JVM-en, alltid daemon-tråder og best for I/O-bundet samtidighet
De eksisterer side om side og deler det samme API-et

Deretter skal du lære om fallgruvene ved pinning og ThreadLocal.

Gratis å komme i gang

Lær deg Java med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 104
Leksjoner: 374

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Plattformtråder kontra virtuelle tråder» gratis?

Ja – hele teksten i «Plattformtråder kontra virtuelle tråder» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Java Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Plattformtråder kontra virtuelle tråder»?

Når hver av dem passer Du øver på Java Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Java Academy?

Ingen tidligere erfaring er nødvendig. Java Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Plattformtråder kontra virtuelle tråder»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Java Academy-leksjonen?

Ja. Alle Java Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Java Academy