Se gestisci un backend Java che deve reggere centinaia di richieste concorrenti senza esplodere in costi di infrastruttura, sai già che il threading classico è un coltello dalla parte sbagliata. Thread pool, contest switching, memoria sprecata. Con Java 21, Oracle ha smesso di aggiungere zucchero sintattico e ha riscritto le fondamenta. Noi, di Meteora Web, abbiamo iniziato a testare le virtual thread su alcuni progetti backend, e il salto è concreto. Zero magia: codice più semplice, prestazioni migliori. E poi ci sono i record migliorati e il pattern matching che ti fa sembrare di scrivere codice funzionale senza lasciare la JVM. Vediamo cosa serve davvero sapere per partire subito.
Il problema che Java 21 risolve (ma che nessuno ti spiega)
Il modello tradizionale di threading in Java — un thread del sistema operativo per ogni richiesta — è inefficiente. Ogni thread occupa circa 1 MB di stack (preallocato) e il cambio di contesto è costoso. Con le virtual thread (Project Loom), ogni thread è gestito dalla JVM come un oggetto leggero (qualche KB). La JVM ne può creare milioni. Il risultato: scrivi codice sincrono (senza callback, senza CompletableFuture annidato) e ottieni scalabilità paragonabile a Node.js o Go. Ma senza cambiare linguaggio.
Virtual thread: esempio pratico
Supponiamo di dover scaricare 1000 URL. Con thread classici dovresti limitare il pool. Con virtual thread:
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.Executors;
public class VirtualThreadExample {
public static void main(String[] args) throws Exception {
var urls = List.of(
"https://meteoraweb.com",
"https://example.com",
"https://httpbin.org/delay/1"
);
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
var futures = urls.stream()
.map(url -> executor.submit(() -> fetchUrl(url)))
.toList();
for (var future : futures) {
System.out.println(future.get());
}
}
}
static String fetchUrl(String url) throws Exception {
var client = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder()
.uri(URI.create(url))
.build();
var response = client.send(request, HttpResponse.BodyHandlers.ofString());
return url + " -> " + response.statusCode();
}
}
Attenzione: il codice è sincrono, ma l’executor lancia thread virtuali per ogni richiesta. La JVM si occupa di sospenderli durante l’attesa I/O. Nessun blocco esplicito. Funziona.
Record: non solo dati immutabili
I record (introdotti in Java 14, diventati stabili in 16) sono il modo più pulito per definire portatori di dati. Java 21 non cambia la sintassi di base, ma aggiunge alcune raffinatezze: costruttori compatti, costanti di classe enumerate, possibilità di overscrittura di metodi di accesso. Ma la vera novità per noi sviluppatori backend è l’integrazione col pattern matching.
Record pattern: destrutturare senza fatica
public sealed interface Payment permits CreditCard, PayPal, BankTransfer {}
record CreditCard(String number, String holder) implements Payment {}
record PayPal(String email) implements Payment {}
record BankTransfer(String iban, String swift) implements Payment {}
public static String processPayment(Payment p) {
return switch (p) {
case CreditCard(var num, var holder) ->
"Carta: " + holder + " - " + num.substring(num.length()-4);
case PayPal(var email) -> "PayPal: " + email;
case BankTransfer(var iban, var swift) -> "Bonifico: " + iban;
};
}
Il pattern matching sui record ti permette di estrarre i campi direttamente nel case, senza cast e senza chiamare getter. Pulito, leggibile, tipizzato.
Pattern matching: lo switch che vorresti da sempre
Lo switch in Java 21 non è più un semplice se-multiplo. Supporta pattern di tipo, pattern di record, e anche pattern di decomposizione. E, cosa fondamentale, il compilatore controlla la completezza: se la tua interfaccia è sealed, puoi omettere il default, perché Java sa che hai coperto tutti i rami.
Un case che semplifica i gestori di eccezioni
Spesso nei progetti backend dobbiamo gestire errori diversi con azioni diverse. Con pattern matching:
public static String handleError(Exception e) {
return switch (e) {
case IOException ex -> "Errore di rete: " + ex.getMessage();
case IllegalArgumentException ex -> "Parametro invalido: " + ex.getMessage();
case RuntimeException ex when ex.getMessage() != null -> "Errore generico: " + ex.getMessage();
default -> "Errore sconosciuto";
};
}
La guardia when permette di filtrare ulteriormente. Nessuna catena di if-else, nessun instanceof manuale.
Cosa significa LTS per te (e per il tuo deploy)
Java 21 è una versione LTS (Long Term Support). Significa che avrai aggiornamenti di sicurezza e bug fix per almeno 8 anni (fino a 2031, salvo proroghe). Per chi come noi segue aziende dal 2017, sapere che la JVM non ti obbliga a migrare ogni 6 mesi è un enorme vantaggio: puoi pianificare la transizione, testare e distribuire senza fretta.
Ma attenzione: virtual thread richiede un aggiornamento delle librerie che usano synchronized in modo bloccante su larga scala. Non tutte le librerie sono pronte. Noi, di Meteora Web, abbiamo visto progetti con JDBC e log4j2 che funzionano bene, ma consigliamo di testare con i propri carichi.
Azioni concrete per iniziare oggi
- Aggiorna il JDK: usa l'installer ufficiale di Oracle JDK 21 o la build OpenJDK di Adoptium. Verifica con
java -versionche sia 21.0.x. - Abilita virtual thread nel tuo application server: se usi Spring Boot 3.2+, configura
spring.threads.virtual.enabled=true. Per Tomcat standalone, segui la guida di Tomcat 10.1. - Riscrivi i tuoi servizi più lenti: prendi una rotta che fa chiamate HTTP o DB con molti thread, sostituisci
ExecutorServiceconExecutors.newVirtualThreadPerTaskExecutor()e misura la differenza. - Sostituisci if-else con switch pattern: inizia dai metodi che gestiscono multi-tipo. Un esempio classico: i converter di DTO.
- Aggiorna le dipendenze: controlla che Hibernate, Spring Data, e il tuo driver DB supportino virtual thread (es. PostgreSQL JDBC 42.6+).
In sintesi — cosa fare adesso
- Scarica e installa JDK 21 su un ambiente di sviluppo isolato.
- Prova il codice di esempio sopra su un tuo endpoint lento.
- Leggi la documentazione ufficiale su Virtual Threads e JEP 441.
- Se stai iniziando con Java moderno, dai un'occhiata anche alla nostra guida su Go per backend: la concorrenza di Java 21 assomiglia molto a quella di Go, ma resta dentro la JVM.
Noi, di Meteora Web, non vendiamo migrazioni: vendiamo soluzioni che funzionano. Se il tuo backend ha bisogno di scala senza riscrivere tutto, Java 21 è il momento giusto per aggiornarsi.
Sponsored Protocol
