Java Academy · Lezione

Creare virtual thread

Thread.ofVirtual ed executor

Creare virtual thread è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Modi per creare thread virtuali

Java offre diversi punti di accesso per creare thread virtuali. I due più importanti sono il builder Thread.ofVirtual() e la factory Executors.newVirtualThreadPerTaskExecutor().

Questa lezione li esamina uno per uno.

Il builder: start

Thread.ofVirtual() restituisce un builder. La chiamata a .start(runnable) crea e avvia immediatamente il thread.

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

Il builder: unstarted

Utilizzate .unstarted(runnable) quando desiderate configurare il thread e avviarlo in un secondo momento.

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

Una factory riutilizzabile

Il builder può produrre una ThreadFactory tramite .factory(). Ogni chiamata a newThread restituisce un nuovo thread virtuale.

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

Il metodo rapido

Thread.startVirtualThread(runnable) è una forma abbreviata per creare e avviare un thread virtuale senza nome con un'unica chiamata.

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

L'approccio con l'executor

Per il codice orientato ai task, preferite Executors.newVirtualThreadPerTaskExecutor(). Crea un nuovo thread virtuale per ogni task inviato.

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

Perché try-with-resources

A partire da Java 19, ExecutorService implementa AutoCloseable. Chiuderlo in un blocco try-with-resources attende il completamento di tutti i task inviati.

In questo modo ottenete un arresto ordinato e strutturato senza dover chiamare manualmente shutdown e awaitTermination.

Invio di molti task

L'executor per task gestisce senza difficoltà un numero enorme di task. Ogni task riceve il proprio thread virtuale.

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

Raccolta dei risultati con Future

submit restituisce un Future, quindi potete raccogliere i valori restituiti proprio come con qualsiasi executor.

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

Builder ed executor a confronto

Scegliete in base all'intento:

Builder / startVirtualThread per thread occasionali o per personalizzare i nomi
newVirtualThreadPerTaskExecutor per inviare raccolte di task e raccoglierne i risultati

Entrambi creano un thread virtuale per ogni unità di lavoro, esattamente ciò che vi serve.

Non memorizzate mai nella cache un executor virtuale

Non riutilizzate un singolo executor di thread virtuali come se fosse un pool fisso di worker. L'executor può essere riutilizzato senza problemi, ma ricordate che ogni task genera un thread completamente nuovo.

Il punto è che non viene effettuato il pooling dei thread: l'executor offre solo un modo pratico per inviare i task.

Verifica rapida

Scegliete il modo migliore per eseguire un grande insieme di task, ciascuno sul proprio thread virtuale.

Riepilogo

Ora sapete come creare thread virtuali:

Thread.ofVirtual().start(...) e .unstarted(...)
La forma compatta Thread.startVirtualThread(...)
.factory() per una ThreadFactory riutilizzabile
Executors.newVirtualThreadPerTaskExecutor() con try-with-resources

Prossimo argomento: scegliere tra thread di piattaforma e thread virtuali.

Domande Frequenti

La lezione «Creare virtual thread» è gratuita?

Sì — il testo completo di «Creare virtual thread» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Creare virtual thread»?

Thread.ofVirtual ed executor Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Creare virtual thread»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Java Academy