Java Academy · Lektion

Platformtråde kontra virtuelle tråde

Hvornår hver af dem er passende

Lektion 3 af 413 trin

Platformtråde kontra virtuelle tråde er en gratis Java Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Java Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Java Academy-kurset indeholder 4 lektioner i alt.

To slags tråde

Java har nu to slags tråde. Platformtråde er de klassiske omslag omkring OS-tråde. Virtuelle tråde er letvægtige og JVM-styrede.

At vide, hvornår du skal vælge hvilken slags, er afgørende, når du skriver skalerbar samtidig Java-kode.

Oprettelse af en platformtråd

Du opretter en platformtråd med Thread.ofPlatform(), som er modstykket 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 af omkostninger

Platformtråde er tunge:

Omkring 1 MB reserveret stack pr. tråd
Langsomme at oprette
Begrænset til nogle få tusinde

Virtuelle tråde er billige: lille indledende stack, hurtig oprettelse og mulighed for millioner.

I/O-bundet arbejde

Hvis din opgave bruger det meste af sin tid på at vente på netværk, disk eller en database, er virtuelle tråde klart bedst.

Mens en virtuel tråd blokerer, frigives dens bærertråd til at køre andre tråde, så en håndfuld OS-tråde kan betjene tusindvis af anmodninger.

CPU-bundet arbejde

Til ren beregning, der aldrig blokerer, giver virtuelle tråde ingen hastighedsforøgelse. Du er begrænset af antallet af kerner.

Her er en fast pulje dimensioneret efter processorerne det rigtige værktøj.

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

Simulering af blokering

Dette kodestykke viser mange virtuelle tråde, der sover samtidig, som en erstatning for blokerende I/O. Prøv at forestille dig 10.000 platformtråde gøre 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());
    }
}

Dæmonstatus

Virtuelle tråde er altid daemon-tråde og kan ikke gøres til ikke-daemon-tråde. Platformtråde arver som standard deres opretters daemon-status, men den kan indstilles eksplicit.

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åde rapporterer altid en prioritet på NORM_PRIORITY, og det har ingen effekt at indstille prioriteten. JVM'en håndterer planlægningen, ikke OS-planlæggeren.

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 opgaver, der venter på I/O? Brug virtuelle tråde.
Tung beregning, der er begrænset af CPU'en? Brug en fast pulje af platformtråde.
Brug for justering af tråde på OS-niveau, f.eks. prioritet eller processortilknytning? Brug platformtråde.

De kan bruges sammen

Du behøver ikke vælge én slags til hele programmet. En typisk app bruger virtuelle tråde til håndtering af anmodninger og en lille pulje af platformtråde til CPU-intensive dele.

Begge bruger den samme Thread-API, så det er problemfrit at blande dem.

Tip til migrering

Når du flytter en I/O-tung tjeneste, er den mindste ændring at skifte executor: Erstat en fast eller cachet pulje med newVirtualThreadPerTaskExecutor().

Vær blot opmærksom på fastlåsning og misbrug af ThreadLocal, som gennemgås i næste lektion.

Hurtig kontrol

Vælg den arbejdsbelastning, hvor virtuelle tråde giver den tydeligste fordel.

Besvar den i den interaktive lektion

Opsummering

Du har sammenlignet de to trådmodeller:

Platformtråde: tunge, OS-understøttede og bedst til CPU-bundet arbejde og justering på OS-niveau
Virtuelle tråde: billige, JVM-styrede, altid daemon-tråde og bedst til I/O-bundet samtidighed
De kan bruges sammen og deler den samme API

Næste emne er faldgruberne ved fastlåsning og ThreadLocal.

Gratis at komme i gang

Lær Java med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 104
Lektioner: 374

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Platformtråde kontra virtuelle tråde” gratis?

Ja — hele teksten til “Platformtråde kontra virtuelle tråde” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Java Academy-kurset, skal du opgradere til CoddyKit PRO. Java Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Platformtråde kontra virtuelle tråde”?

Hvornår hver af dem er passende Du øver dig i Java Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Java Academy?

Der kræves ingen tidligere erfaring. Java Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Platformtråde kontra virtuelle tråde”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Java Academy-lektion?

Ja. Alle Java Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Java Academy