Java 21 LTS rappresenta un turning point per lo sviluppo enterprise moderno. Tre innovazioni chiave trasformano il modo in cui scrivi Spring Boot 3.4: virtual threads che parallelizzano I/O senza thread OS costosi, pattern matching che semplifica logica complessa, e records immutabili per value object robusti. Questo articolo esplora ogni feature con esempi reali dal backend di Federico Calò (Spring Boot 3.4, 1521 file Java).
Perché Java 21? LTS e Adoption Timeline
Java 21 è Long-Term Support. Per l'Oracle JDK il supporto Premier arriva a settembre 2028 e l'Extended a settembre 2031; le distribuzioni OpenJDK (Temurin, Corretto e altre) hanno date proprie, da controllare sul sito del fornitore. Java 21 rende definitivi i virtual threads (JEP 444), il pattern matching per switch (JEP 441) e i record patterns (JEP 440), e introduce le Sequenced Collections (JEP 431). Spring Boot 3.4 richiede almeno Java 17; i virtual threads richiedono Java 21 e Spring Boot 3.2 o successivo.
Da Java 17 a 21 la migrazione è di norma poco costosa, ma non a costo zero: i punti da verificare sono le librerie che manipolano il bytecode o usano la reflection (per esempio Lombok richiede almeno la 1.18.30 per supportare JDK 21), le versioni di Mockito/ByteBuddy e gli agenti (JaCoCo). Il guadagno dei virtual threads non è automatico: si ottiene solo dopo averli abilitati (vedi sotto) e solo se il carico è dominato da attese di I/O.
Feature 1: Virtual Threads - Concorrenza Senza Thread Pool
Il Problema con Thread OS Classici
Spring Boot tipicamente gestisce ~200 thread HTTP concorrenti (Tomcat default). Ogni thread OS consuma ~1-2 MB di memoria: 200 thread = 200-400 MB. Se una request I/O blocca il thread (database, API esterna), quel thread rimane idle finché non finisce l'I/O. Con 10.000 request/sec concurrent, esaurisce rapidamente il pool.
Virtual Threads: Lightweight Scheduling
Virtual threads (Project Loom, JEP 444, definitivi in Java 21) sono thread Java leggeri gestiti dal runtime JVM, non dal sistema operativo. Il loro stack cresce in heap solo quanto serve, quindi se ne possono creare centinaia di migliaia (l'ordine di grandezza dipende dall'uso di memoria del tuo codice, da misurare). Quando un virtual thread si blocca su I/O, il runtime lo smonta dal thread OS carrier e lo riprende più tardi.
// PRE Java 21: ThreadPoolExecutor con 200 thread max
@Configuration
public class ThreadPoolConfig {
@Bean
public ExecutorService threadPool() {
return Executors.newFixedThreadPool(200); // 200 OS threads, 200-400 MB
}
}
// Bottleneck: request lenta I/O blocca il thread
@RestController
public class ArticleController {
@PostMapping("/articles/{id}/index-ai")
public void indexArticle(@PathVariable Long id) {
// Se MLService è lento (2s), questo thread rimane bloccato 2s
mlService.indexArticleVector(id); // BLOCKING
}
}
// POST Java 21 + Spring Boot 3.2+: una proprietà, NON attiva di default
// application.yml:
// spring:
// threads:
// virtual:
// enabled: true
// Stesso codice, ma ora:
// - Non blocca un thread OS costoso
// - La JVM può tenere in attesa molti più virtual thread di quanti thread OS potresti creare
// - Lo stack di un virtual thread vive in heap e cresce solo quanto serve
@RestController
public class ArticleController {
@PostMapping("/articles/{id}/index-ai")
public void indexArticle(@PathVariable Long id) {
mlService.indexArticleVector(id); // VIRTUAL THREAD: può bloccarsi senza impatto
}
}
// Test: simulare alta concorrenza è ora triviale
@Test
public void testHighConcurrency() throws InterruptedException {
ExecutorService vthreads = Executors.newVirtualThreadPerTaskExecutor();
IntStream.range(0, 10_000).forEach(i ->
vthreads.submit(() ->
restTemplate.getForEntity("http://localhost:8080/api/articles/" + i, String.class)
)
);
// 10.000 virtual threads, nessun pool exhaustion
}
Spring Boot 3.4 + Virtual Threads
Spring Boot non usa i virtual threads per default, nemmeno con Java 21. Dalla versione 3.2 si attivano con spring.threads.virtual.enabled=true: Tomcat gestisce allora ogni richiesta su un virtual thread, e anche l'executor delle attività @Async e dello scheduling li usa. Il guadagno dipende dal carico: aiuta quando la maggior parte del tempo di una richiesta è attesa di I/O, non aiuta un carico limitato dalla CPU, e non aumenta la capacità del database (vedi "Il collo di bottiglia si sposta" più sotto). Non esiste un miglioramento di throughput valido in generale: va misurato sul tuo servizio.
Feature 2: Pattern Matching - Semplificare Switch Complessi
Switch Expressions vs If-Else Chains
Il pattern matching per switch (JEP 441) e i record patterns (JEP 440), entrambi definitivi in Java 21, uniscono controllo del tipo, destrutturazione e condizioni in espressioni switch leggibili.
// PRE Java 21: Verbose instanceof chain
public String getUserAccessLevel(Object user) {
if (user instanceof User u) {
if (u.isPremium()) return "premium";
if (u.isAdmin()) return "admin";
return "free";
} else if (user instanceof ApiToken token) {
return token.scope();
} else {
throw new IllegalArgumentException();
}
}
// POST Java 21: Pattern matching + sealed classes
public sealed interface Credential permits User, ApiToken, OAuthToken {}
public record User(String email, boolean isPremium, boolean isAdmin) implements Credential {}
public record ApiToken(String scope, long expiresAt) implements Credential {}
public record OAuthToken(String provider, String subject) implements Credential {}
public String getUserAccessLevel(Credential credential) {
return switch (credential) {
case User u when u.isPremium() -> "premium";
case User u when u.isAdmin() -> "admin";
case User u -> "free";
case ApiToken token -> token.scope();
case OAuthToken oauth -> "oauth-" + oauth.provider();
};
}
// Record patterns: definitivi in Java 21 (JEP 440). I pattern anonimi con "_" (JEP 456)
// arrivano solo in Java 22: in Java 21 vanno nominati tutti i componenti
public String getUserEmail(Credential credential) {
return switch (credential) {
case User(var email, var premium, var admin) -> email; // Destructure record fields
case ApiToken(var scope, var expiresAt) -> "token-" + scope;
case OAuthToken(var provider, var subject) -> subject;
};
}
Feature 3: Records - Value Objects Immutabili
Records vs Lombok vs Manual POJO
Records (JEP 395, standard since Java 16) generano automaticamente constructor, equals(), hashCode(), toString() per immutable data carriers. Zero boilerplate.
// PRE Java 21: Boilerplate manuale
public class Email {
private final String value;
public Email(String value) {
if (!value.contains("@")) throw new IllegalArgumentException();
this.value = value;
}
public String value() { return value; }
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Email email = (Email) o;
return value.equals(email.value);
}
@Override
public int hashCode() {
return value.hashCode();
}
@Override
public String toString() {
return "Email(" + value + ")";
}
}
// POST Java 21: Record (30 righe → 5 righe)
public record Email(String value) {
public Email { // Compact constructor: validation
if (!value.contains("@")) throw new IllegalArgumentException("Invalid email");
}
}
// Uso identico, zero garbage method:
Email email = new Email("user@example.com");
System.out.println(email); // Email[value=user@example.com]
System.out.println(email.value()); // user@example.com
// Records sono perfetti per domain value objects in Clean Architecture
public record User(UserId id, Email email, Money balance) { }
public record Money(BigDecimal amount, Currency currency) { }
// Test: records sono immutabili, thread-safe, hashable
@Test
public void testRecordImmutability() {
Money m1 = new Money(BigDecimal.TEN, Currency.getInstance("EUR"));
Money m2 = new Money(BigDecimal.TEN, Currency.getInstance("EUR"));
assertEquals(m1, m2); // Same value = equals true
assertEquals(m1.hashCode(), m2.hashCode()); // Safe for HashSet/HashMap
}
Feature 4: Sealed Classes - Restrizione di Ereditarietà
Sealed Classes per Model Safety
Sealed classes (JEP 409) limitano quali classi possono estendere un'interfaccia. Elimina wild subclassing, facilita exhaustiveness checking in switch.
// Senza sealed: chiunque potrebbe estendere Credential
public interface Credential { }
public class User implements Credential { } // OK
public class Malicious implements Credential { } // Oops!
// Con sealed: solo User, ApiToken, OAuthToken permettiti
public sealed interface Credential permits User, ApiToken, OAuthToken { }
public record User(String email) implements Credential { }
public record ApiToken(String scope) implements Credential { }
public record OAuthToken(String provider) implements Credential { }
// Switch su sealed type è exhaustive (compiler lo verifica)
public String getCredentialType(Credential cred) {
return switch (cred) {
case User u -> "user";
case ApiToken t -> "api-token";
case OAuthToken o -> "oauth";
// No default needed! Compiler enforces all permutations
};
}
// Senza sealed: switch potrebbe lasciar fuori permutazioni
// Con sealed: impossibile (compilatore errore)
Feature 5: Sequenced Collections - Ordine Garantito
New API: SequencedCollection, SequencedSet, SequencedMap
SequencedCollections (JEP 431) formalizzano l'ordine di iterazione. Utile per articoli, ranking, timeline.
// PRE Java 21: ambiguità su ordine
List<Article> articles = new ArrayList<>();
Set<String> tags = new LinkedHashSet<>(); // Preserves insertion order, but no API
// POST Java 21: API chiara
SequencedCollection<Article> articles = new LinkedList<>();
// Accesso first/last esplicito
Article first = articles.getFirst();
Article last = articles.getLast();
// Reverse view
SequencedCollection<Article> reversed = articles.reversed();
// SequencedMap per blog posts
SequencedMap<Long, Article> timeline = new LinkedHashMap<>();
timeline.put(1L, article1);
timeline.put(2L, article2);
// First/last entry
System.out.println(timeline.firstEntry()); // 1 -> article1
System.out.println(timeline.lastEntry()); // 2 -> article2
// Use case: trending articles (by insertion/publish time)
@Service
public class TrendingArticlesService {
public List<Article> getRecent(int limit) {
SequencedCollection<Article> all = articleRepository.findAllOrdered();
return all.reversed().stream().limit(limit).toList(); // Most recent first
}
}
Feature 6: String Templates (preview in Java 21, poi ritirate)
Le string templates (JEP 430) erano una funzionalità in anteprima in Java 21: richiedevano --enable-preview e un prefisso di processore (STR."... \{valore} ..."). Non sono arrivate allo stato definitivo: dopo una seconda preview in Java 22 sono state rimosse da JDK 23, in attesa di un nuovo design. Non vanno usate nel codice di produzione, e l'esempio che compariva in una versione precedente di questo articolo (senza il prefisso STR.) non compilava. Per ciò che serve davvero oggi:
// Testo formattato: text block (Java 15) + formatted() (Java 15)
String riepilogo = """
Article ID: %d
Title: %s
Published: %s
""".formatted(article.id(), article.title(), article.publishedAt());
// JSON: mai costruirlo a mano. Un titolo con virgolette o a-capo produce JSON non valido
// (e, in un contesto sensibile, un'iniezione). Lascia che sia Jackson a serializzare il record.
public record ArticleSummary(Long id, String title, String slug) { }
@GetMapping("/articles/{id}")
public ArticleSummary getArticle(@PathVariable Long id) {
Article a = service.findById(id);
return new ArticleSummary(a.id(), a.title(), a.slug()); // Spring serializza in JSON
}
Caso d'uso illustrativo: credenziali e articoli
Il codice di questa sezione è illustrativo e non è il codice del backend: serve a vedere le funzionalità insieme. Il codice reale è nella sezione che segue.
Integrazione Tutte le Feature
// Domain layer: sealed credentials + records
public sealed interface Credential permits UserCredential, ApiKeyCredential {}
public record UserCredential(UserId userId, Email email, boolean isPremium)
implements Credential { }
public record ApiKeyCredential(String keyHash, Set<String> scopes, long expiresAt)
implements Credential { }
// Use case: fetch trending articles with virtual thread support
@Service
public class GetTrendingArticlesUseCase {
private final ArticleRepository articleRepo;
public List<ArticleResponse> execute(int limit) {
// Virtual thread: blocking I/O doesn't block OS thread
var articles = articleRepository.findTrendingByPublishedAt(limit);
return articles.stream()
.map(ArticleResponse::fromEntity)
.toList();
}
}
// Controller: pattern matching for auth + sealed types
@RestController
public class ArticleController {
@GetMapping("/api/articles/trending")
public ResponseEntity<List<ArticleResponse>> getTrending(
@RequestHeader(value = "Authorization", required = false) String auth
) {
Credential credential = parseCredential(auth);
// Pattern matching: exhaustive, safe
String accessLevel = switch (credential) {
case UserCredential u when u.isPremium() -> "premium";
case UserCredential u -> "free";
case ApiKeyCredential api -> "api-" + api.scopes().size();
};
return ResponseEntity.ok(getTrendingArticles());
}
}
// Domain: value object record with compact constructor
public record Article(
ArticleId id,
String title,
String slug,
Email author,
ZonedDateTime publishedAt,
int readTimeMinutes,
String category
) {
public Article { // Compact constructor: validate
Objects.requireNonNull(id);
Objects.requireNonNull(title);
if (readTimeMinutes <= 0) throw new IllegalArgumentException("Read time must be > 0");
}
}
// Repository: leverage sequenced collections for timeline
@Repository
public class ArticleRepository {
public SequencedCollection<Article> findTrendingByPublishedAt(int limit) {
// Returns LinkedList (preserves publish order)
List<Article> articles = jpaRepository
.findByPublishedOrderByPublishedAtDesc(Pageable.ofSize(limit))
.stream()
.toList();
return new LinkedList<>(articles);
}
}
Performance Impact e Benchmarking
Virtual Threads: cosa aspettarsi, senza numeri inventati
Una versione precedente di questa sezione riportava un benchmark JMH con guadagni percentuali precisi (+35-50% di throughput, -80% di memoria, -25% sulla latenza p99). Quei numeri non avevano una fonte verificabile e sono stati rimossi: i risultati reali dipendono dal rapporto fra attesa di I/O e calcolo, dal pool di connessioni, dal driver e dall'hardware. Quello che si può affermare in modo solido è qualitativo.
- Carico limitato dall'I/O con molte richieste concorrenti: i virtual threads permettono di avere molte più richieste «in attesa» di quanti thread OS potresti permetterti, senza riscrivere il codice in stile reattivo.
- Carico limitato dalla CPU: nessun beneficio (un virtual thread non calcola più in fretta).
- Memoria: uno stack di virtual thread è molto più piccolo di uno di un thread di piattaforma, ma non è zero; la misura giusta si ottiene profilando il tuo servizio.
- Il metodo: prima di decidere, fai un test di carico con e senza
spring.threads.virtual.enabledsullo stesso codice e hardware, e confronta throughput e latenza p99.
Best Practices e Gotcha
Virtual Threads Gotcha
- Pinning con
synchronized(Java 21): un virtual thread dentro un bloccosynchronizedche esegue I/O bloccante non libera il carrier. Per le sezioni critiche con I/O usaReentrantLock; il limite è stato rimosso in JDK 24 (JEP 491). - ThreadLocal: funziona anche nei virtual threads, ma con milioni di thread ogni copia pesa; evita di mettere oggetti grandi in un
ThreadLocale valuta gli scoped values (preview in Java 21). - Profiling: Tools tradizionali (JProfiler, YourKit) potrebbero non supportare virtual threads perfettamente (aggiorna a latest version).
Pattern Matching Best Practice
- Always place most specific case first in switch (before general wildcards).
- Use guard conditions (when) per evitare nesting.
- Combine sealed classes + pattern matching per exhaustiveness.
Records Best Practice
- Use for immutable value objects (email, money, VO domain).
- Avoid overly large records (>5-6 fields); extract nested records instead.
- Records sono final: non possono essere subclassati (by design).
FAQ - Domande Frequenti
Q1: Devo migrare a Java 21 oggi?
Risposta: Se sei su Java 17 con un'applicazione enterprise, di norma sì: Java 21 è una LTS e la migrazione è modesta, ma verifica le librerie che usano reflection o bytecode (vedi sopra). I virtual threads sono un motivo in più solo se il tuo carico è dominato da attese di I/O, e vanno abilitati e misurati. Se sei su Java 8 o 11, la migrazione è più grande: valuta costi e benefici.
Q2: Virtual threads funzionano con tutti i database driver?
Risposta: Un driver JDBC blocca il thread durante la query, e con un virtual thread il runtime può smontarlo dal carrier mentre attende. Ci sono però due eccezioni da conoscere. La prima è il pinning: in Java 21 un virtual thread dentro un blocco synchronized (o un metodo nativo) resta agganciato al carrier mentre attende, e un driver o un pool che sincronizza attorno all'I/O ne risente. Il problema dei blocchi synchronized è stato risolto in JDK 24 (JEP 491). La seconda è che il pool di connessioni resta un limite: con 20 connessioni, 10.000 virtual threads sono comunque serializzati su 20 query alla volta. R2DBC non ne ha bisogno, perché è asincrono per costruzione.
Q3: Posso usare Spring 5 con Java 21?
Risposta: Dipende dalla versione di Spring Framework. Il supporto a Java 21 e ai virtual threads arriva con Spring Framework 6.1 e Spring Boot 3.2. Spring Framework 5 non è pensato per Java 21 e non ha il supporto ai virtual threads: se sei su Spring 5, la migrazione a Spring Boot 3 (e al namespace jakarta.*) viene prima di quella a Java 21.
Q4: Records vs Lombok @Value?
Risposta: Records sono language-level (zero runtime magic), Lombok è annotation processor. Records: preferiti per domain models. Lombok: ancora utile per legacy POJO con builder, logging. New code: preferisci records.
Q5: Pattern matching funziona con XML/protobuf deserialization?
Risposta: Pattern matching opera su Java object graph, non su raw bytes. Dopo deserializzazione (Jackson, protobuf), pattern matching funziona normalmente. Utile per controllare tipo di payload in REST handler.
Conclusione: Il Futuro di Spring Boot è Java 21
Java 21 LTS fonde stabilità enterprise con innovazione linguistica (virtual threads, pattern matching, records). Per uno sviluppatore Spring Boot il valore concreto è questo: una concorrenza più semplice da scrivere (se abiliti i virtual threads e il carico lo giustifica), tipi più precisi con pattern matching e sealed classes, un modello di dominio più compatto con i record.
Nel backend di questo sito Java 21 è la versione di compilazione (<release>21</release>) e i virtual threads sono usati in un punto preciso, non su tutto il server: la sezione "Cosa fa davvero il backend" qui sotto mostra dove e perché.
Prossimi Passi
- Upgrade Spring Boot a 3.4+, target Java 21 in pom.xml/build.gradle.
- Profila current app con Java 21 (benchmark baseline).
- Refactor Value Objects in records (domain layer first).
- Introduce sealed types per domain models (Auth, Credential, Payment).
- Monitora JVM metrics (virtual thread count, carrier thread utilization) con Actuator/Prometheus.
Risorse Esterne
- Inside.java - Java Language Updates
- Spring Blog - Latest Release Notes
- Project Loom - Virtual Threads Spec
- OpenJDK - Download Java 21
Cosa fa davvero il backend: virtual thread in un punto, non ovunque
Il backend di questo sito (Spring Boot 3.4, Java 21) non imposta spring.threads.virtual.enabled: Tomcat gira quindi su thread di piattaforma. Usa i virtual threads in un punto solo, il controller che trasmette in streaming i risultati di una query sui dataset come server-sent events. È un esempio di adozione chirurgica, con i suoi costi.
// DatasetStreamController (estratto semplificato)
private static final long SSE_TIMEOUT_MS = 60_000L;
private static final ExecutorService VIRTUAL_EXECUTOR =
Executors.newVirtualThreadPerTaskExecutor();
@PostMapping(value = "/{slug}/query/stream", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public SseEmitter queryStream(@PathVariable String slug, @RequestBody(required = false) Map<String, Object> body /* ... */) {
SseEmitter emitter = new SseEmitter(SSE_TIMEOUT_MS);
// ... autenticazione risolta in modo sincrono, così il 401 è immediato ...
CompletableFuture.runAsync(() -> {
// carica il dataset, riserva 1 credito, esegue la query,
// invia le righe una per evento, poi conferma o rimborsa il credito
}, VIRTUAL_EXECUTOR);
return emitter; // il thread del servlet torna subito libero
}
Perché qui
Una sessione SSE dura fino a 60 secondi e passa quasi tutto il tempo a inviare righe a un client che può essere lento. Se la gestisse un thread del servlet, quel thread resterebbe occupato per tutta la durata, e con il tetto di thread di Tomcat poche sessioni lente saturerebbero il server. Con runAsync su un virtual thread, il thread HTTP viene restituito subito e l'invio avviene su un thread che costa poco restare in attesa. La scelta è documentata nel sorgente insieme a un'alternativa scartata: il controller dichiara di usare SseEmitter e non Flux di WebFlux, perché il progetto è su stack servlet e introdurre Reactor richiederebbe una migrazione o un ponte tra i due modelli, sproporzionati per la scala attuale. È il compromesso che i virtual threads rendono possibile: codice bloccante e lineare, senza il costo di riscrivere in stile reattivo.
Il collo di bottiglia si sposta
I virtual threads non aggiungono capacità al database. Il pool di connessioni del backend è di 10 connessioni in sviluppo e 20 in produzione, e il servizio gira con 512 MB di heap massimo. Con migliaia di virtual threads in attesa, l'attesa si trasferisce sul pool (con timeout di 20 secondi sulla richiesta di una connessione) e sulla memoria. Qui il rischio è contenuto da tre fattori, nessuno dei quali è l'executor: ogni sessione richiede autenticazione e riserva un credito, ogni stream è limitato a 500 righe, e la query usa la connessione solo per il tempo dell'esecuzione (le righe vengono lette prima e inviate poi). Si noti che questo ultimo punto contraddice il commento del controller, che parla di righe «mai accumulate»: l'elenco, fino a 500 righe, viene caricato in memoria prima di essere inviato un evento alla volta.
Cosa si paga con un executor statico
- Nessun arresto ordinato. L'executor è un campo statico che nessuno chiude: allo spegnimento le sessioni in corso vengono interrotte con il processo. Un executor gestito da Spring (
spring.threads.virtual.enabledo un bean condestroyMethod) si integra con lo shutdown. - Nessun tetto sulle sessioni concorrenti.
newVirtualThreadPerTaskExecutor()non limita il numero di thread. Il limite effettivo viene da autenticazione, crediti e pool, non da un semaforo esplicito: se serve un tetto duro, va aggiunto (per esempio unSemaphoreacquisito prima dirunAsync). - Il contesto del thread non si propaga. L'id di correlazione del log (MDC) è legato al thread della richiesta: nel codice eseguito su
runAsyncle righe di log escono senza. Vedi Java nel mondo reale per il rimedio con unTaskDecoratoro la copia manuale del MDC.
Quando abilitarli su tutto il server
Abilitare spring.threads.virtual.enabled=true estende il comportamento a ogni richiesta, e cambia anche l'executor di @Async. È sensato quando le richieste passano molto tempo in attesa di I/O esterno (servizi remoti, query lente) e il pool di connessioni è dimensionato per assorbirne la concorrenza. Prima di farlo: un test di carico sul codice reale, una verifica del pinning (-Djdk.tracePinnedThreads=full in Java 21 mostra dove un virtual thread resta agganciato al carrier), e un controllo delle librerie che sincronizzano attorno all'I/O. Per il confronto con altri modelli di concorrenza vedi Concorrenza e multithreading e Virtual threads e concorrenza strutturata; per il resto della serie, il domain layer.

Commenti
Caricamento commenti...
Accedi per commentare