Java Academy · Lektion

Skapa virtuella trådar

Thread.ofVirtual och exekverare.

Lektion 2 av 413 steg

Skapa virtuella trådar är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 2 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.

Sätt att skapa virtuella trådar

Java erbjuder flera sätt att skapa virtuella trådar. De två viktigaste är byggaren Thread.ofVirtual() och fabriken Executors.newVirtualThreadPerTaskExecutor().

I den här lektionen går vi igenom båda.

Byggaren: start

Thread.ofVirtual() returnerar en byggare. När Ni anropar .start(runnable) skapas tråden och startas omedelbart.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = Thread.ofVirtual().start(() ->
            System.out.println("Started directly"));
        t.join();
    }
}

Byggaren: unstarted

Använd .unstarted(runnable) när Ni vill konfigurera tråden och starta den senare.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = Thread.ofVirtual().unstarted(() ->
            System.out.println("Started later"));
        System.out.println("Before start, alive? " + t.isAlive());
        t.start();
        t.join();
    }
}

En återanvändbar fabrik

Byggaren kan skapa en ThreadFactory via .factory(). Varje anrop till newThread ger en ny virtuell tråd.

import java.util.concurrent.ThreadFactory;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        ThreadFactory factory = Thread.ofVirtual().name("job-", 0).factory();
        Thread a = factory.newThread(() ->
            System.out.println(Thread.currentThread().getName()));
        Thread b = factory.newThread(() ->
            System.out.println(Thread.currentThread().getName()));
        a.start(); b.start();
        a.join(); b.join();
    }
}

Hjälpmetoden

Thread.startVirtualThread(runnable) är en kortform för att skapa och starta en namnlös virtuell tråd i ett enda anrop.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = Thread.startVirtualThread(() ->
            System.out.println("One-liner virtual thread"));
        t.join();
    }
}

Executor-metoden

För uppgiftsorienterad kod bör Ni föredra Executors.newVirtualThreadPerTaskExecutor(). Den skapar en ny virtuell tråd för varje inskickad uppgift.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
            exec.submit(() -> System.out.println("task one"));
            exec.submit(() -> System.out.println("task two"));
        }
        System.out.println("All tasks submitted and completed");
    }
}

Varför try-with-resources

Sedan Java 19 implementerar ExecutorService AutoCloseable. Om Ni stänger den i ett try-with-resources-block väntar den på att alla inskickade uppgifter ska slutföras.

Det ger en ren och strukturerad avstängning utan manuella anrop till shutdown och awaitTermination.

Skicka in många uppgifter

Exekveraren per uppgift hanterar utan problem mycket stora mängder uppgifter. Varje uppgift får sin egen virtuella tråd.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args) {
        AtomicInteger sum = new AtomicInteger();
        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 1; i <= 1000; i++) {
                final int n = i;
                exec.submit(() -> sum.addAndGet(n));
            }
        }
        System.out.println("Sum 1..1000 = " + sum.get());
    }
}

Samla in resultat med Future

submit returnerar en Future, så Ni kan samla in returvärden precis som med vilken annan executor som helst.

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws Exception {
        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
            Future<Integer> f = exec.submit(() -> 6 * 7);
            System.out.println("Result: " + f.get());
        }
    }
}

Byggare jämfört med executor

Välj utifrån avsikten:

Builder / startVirtualThread för engångstrådar eller anpassad namngivning
newVirtualThreadPerTaskExecutor för att skicka in samlingar av uppgifter och samla in resultat

Båda skapar en virtuell tråd per arbetsenhet, vilket är precis det Ni vill ha.

Cachelagra aldrig en virtuell executor

Återanvänd inte en enda executor för virtuella trådar som om den vore en fast pool av arbetstrådar. Det går bra att återanvända själva exekveraren, men kom ihåg att varje uppgift skapar en helt ny tråd.

Poängen är att trådarna inte poolas; det är bara inskickningen av uppgifter som förenklas.

Snabbtest

Välj det bästa sättet att köra en stor mängd uppgifter, där varje uppgift körs i sin egen virtuella tråd.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Nu vet Ni hur virtuella trådar skapas:

Thread.ofVirtual().start(...) och .unstarted(...)
Thread.startVirtualThread(...) som enradare
.factory() för en återanvändbar ThreadFactory
Executors.newVirtualThreadPerTaskExecutor() med try-with-resources

Härnäst: att välja mellan plattforms- och virtuella trådar.

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 ”Skapa virtuella trådar” gratis?

Ja – hela texten till ”Skapa virtuella trådar” 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 ”Skapa virtuella trådar”?

Thread.ofVirtual och exekverare. 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 2 av 4.

Hur lång tid tar lektionen ”Skapa virtuella trådar”?

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

← Tillbaka till Java Academy