`Fire de execuție virtuale` în Java

Firele virtuale sunt fire de execuție foarte ușoare, gestionate de JVM: poți porni zeci de mii de sarcini care așteaptă fără să blochezi sistemul.

Sintaxă

Thread t = Thread.ofVirtual().start(() -> ...);
Thread.startVirtualThread(() -> ...);

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> ...);
}   // close() așteaptă toate sarcinile

Ce face `Fire de execuție virtuale`

Un fir obișnuit (platform thread) corespunde unui fir al sistemului de operare și ocupă memorie multă; câteva mii sunt deja o problemă. Un fir virtual este gestionat de JVM: când așteaptă (o cerere de rețea, un fișier, Thread.sleep), își eliberează firul real, care poate rula alt fir virtual. Așa poți avea sute de mii de fire virtuale.

Se creează cu Thread.ofVirtual().start(...), Thread.startVirtualThread(...) sau, cel mai des, cu Executors.newVirtualThreadPerTaskExecutor(), care pornește un fir virtual nou pentru fiecare sarcină. Executorul se folosește în try-with-resources: close() așteaptă terminarea tuturor sarcinilor.

Firele virtuale ajută la sarcinile care așteaptă mult (servere web, apeluri către API-uri și baze de date), nu la calcule grele, unde numărul de nuclee rămâne limita. Codul rămâne simplu, scris „pas cu pas”, fără callback-uri.

Exemple

Exemplul 1: Un fir virtual

isVirtual() confirmă tipul firului. join() așteaptă terminarea lui înainte ca main să continue.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = Thread.ofVirtual().name("descarcare-factura").start(() -> {
            Thread curent = Thread.currentThread();
            System.out.println("rulez în " + curent.getName() + ", virtual: " + curent.isVirtual());
        });
        t.join();
        System.out.println("main e virtual? " + Thread.currentThread().isVirtual());
    }
}

Rezultat

rulez în descarcare-factura, virtual: true
main e virtual? false

Exemplul 2: 10.000 de sarcini care așteaptă

Fiecare sarcină „așteaptă” 1 secundă (ca un apel de rețea). Cu fire virtuale, toate 10.000 rulează în paralel și totul durează puțin peste o secundă, nu 10.000 de secunde. Rezultatele sunt adunate după ce executorul a terminat.

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        long start = System.nanoTime();
        List<Future<Integer>> rezultate = new ArrayList<>();
        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 1; i <= 10_000; i++) {
                int comanda = i;
                rezultate.add(executor.submit(() -> {
                    Thread.sleep(Duration.ofSeconds(1));
                    return comanda % 7;
                }));
            }
        }
        long suma = 0;
        for (Future<Integer> f : rezultate) {
            suma += f.get();
        }
        double secunde = (System.nanoTime() - start) / 1e9;
        System.out.println("sarcini terminate: " + rezultate.size());
        System.out.println("suma rezultatelor: " + suma);
        System.out.println("sub 5 secunde? " + (secunde < 5));
    }
}