Guida Java 27

Guida Java 27

Guida Java 27

Il 15 settembre 2026 Oracle ha rilasciato Java 27, la diciottesima feature release consegnata puntualmente secondo il ciclo semestrale del progetto OpenJDK. La versione introduce nove JDK Enhancement Proposal (JEP) che toccano crittografia post-quantistica, gestione della memoria, concorrenza, calcolo vettoriale e osservabilità, con un occhio dichiaratamente rivolto ai carichi di lavoro cloud-native e all’intelligenza artificiale. Questa guida accompagna sviluppatori professionisti, junior, senior e ingegneri del software che già conoscono Java ma non hanno seguito le ultime release, attraverso le novità principali, con esempi di codice, best practice operative e un quadro dell’ecosistema che si aggiorna insieme al linguaggio.

Indice dei contenuti – Guida Java 27

1. Java 27: quando arriva e perché conta per chi sviluppa oggi

2. Crittografia post-quantistica: TLS 1.3 pronto al futuro (JEP 527)

3. G1 come Garbage Collector predefinito ovunque (JEP 523)

4. Concorrenza strutturata: task paralleli senza caos (JEP 533)

5. Vector API: calcolo vettoriale ad alte prestazioni (JEP 537)

6. Codifica PEM degli oggetti crittografici (JEP 538)

7. Un ecosistema sincronizzato: Helidon, JavaFX, Jipher e Java Verified Portfolio

8. Le altre JEP di Java 27 in sintesi

9. Java 27 al servizio dei carichi di lavoro AI e degli agenti intelligenti

10. Best practice per iniziare un progetto con Java 27

11. Conclusioni: la formazione continua come vantaggio competitivo

1. Java 27: quando arriva e perché conta per chi sviluppa oggi

Java 27 è disponibile in General Availability dal 15 settembre 2026 ed è la diciottesima release consegnata rispettando la cadenza semestrale adottata da Oracle e dalla comunità OpenJDK dal 2017 in poi. Si tratta di una release non-LTS (Long-Term Support): la seconda dopo Java 25, che a settembre 2025 ha ricevuto lo status di Long-Term Support e resta quindi il riferimento più stabile per i sistemi di produzione critici. Oracle continuerà ad aggiornare Java 27 fino a marzo 2027, quando sarà sostituita da Java 28.

Per gli sviluppatori che seguono Java in modo discontinuo, questo significa una cosa pratica: Java 27 non sostituisce necessariamente Java 25 in produzione, ma rappresenta l’anteprima più aggiornata delle direzioni che il linguaggio sta prendendo, crittografia resistente al calcolo quantistico, concorrenza strutturata, calcolo vettoriale e un’attenzione crescente ai workload di intelligenza artificiale. Conoscere queste novità oggi significa poter valutare con cognizione di causa quando e come adottarle, sia su Java 27 stesso sia, più avanti, sulla prossima release LTS.

2. Crittografia post-quantistica: TLS 1.3 pronto al futuro (JEP 527)

La novità di sicurezza più rilevante di Java 27 è la JEP 527, che introduce lo scambio di chiavi ibrido post-quantistico per TLS 1.3. L’idea di fondo è semplice da spiegare con un’analogia: oggi una connessione TLS negozia una chiave segreta usando algoritmi come ECDHE, la cui sicurezza si basa sulla difficoltà di risolvere certi problemi matematici con i computer classici. Un computer quantistico sufficientemente potente potrebbe però risolvere quegli stessi problemi in tempi ragionevoli, vanificando la protezione, anche retroattivamente, se il traffico cifrato oggi viene registrato e decifrato in futuro (il cosiddetto scenario “harvest now, decrypt later”).

Lo scambio ibrido risolve il problema combinando un algoritmo classico con un algoritmo quantum-resistant basato su reticoli (ML-KEM, già introdotto da JEP 496 in JDK 24): la chiave di sessione finale dipende da entrambi i contributi, quindi resta sicura anche se uno dei due algoritmi venisse compromesso. La parte più interessante per chi sviluppa è che questa protezione è trasparente: le applicazioni che si affidano alle API standard di javax.net.ssl beneficiano del nuovo scambio di chiavi senza modificare una sola riga di codice, semplicemente eseguendo l’applicazione su Java 27.

Java 27 rafforza inoltre le fondamenta crittografiche post-quantistiche in modo più ampio: aggiorna la codifica delle chiavi private per ML-KEM e ML-DSA, introduce miglioramenti prestazionali per ML-KEM, ML-DSA, X25519 ed Ed25519, e aggiunge un nuovo comando diagnostico, jcmd VM.security_properties, per ispezionare a runtime quali proprietà di sicurezza sono effettivamente attive su una JVM in produzione:

# Ispeziona le proprietà di sicurezza attive su una JVM in esecuzione jcmd <pid> VM.security_properties

Per i team che gestiscono comunicazioni cifrate a lungo termine (settore bancario, pubblica amministrazione, sanità), questa è la prima release Java in cui la migrazione verso la crittografia post-quantistica smette di essere una discussione teorica e diventa un’opzione già attiva di default.

3. G1 come Garbage Collector predefinito ovunque (JEP 523)

Proseguiamo con la Guida Java 27. Fino a Java 26, la scelta del Garbage Collector predefinito dipendeva dall’ambiente di esecuzione: su macchine di classe server la JVM selezionava G1 (Garbage-First), mentre su ambienti più modesti — container piccoli, dispositivi con poca memoria, alcune configurazioni client — poteva ripiegare sul Serial Collector, pensato per applicazioni single-thread con heap ridotto. La JEP 523 elimina questa distinzione: quando non si specifica esplicitamente un collector con un flag da riga di comando, la JVM sceglie sempre G1, in qualsiasi ambiente.

L’analogia più utile è quella di un termostato intelligente che prima cambiava logica a seconda della stanza in cui veniva installato, e ora usa sempre la stessa strategia efficiente ovunque, adattando i parametri interni invece di cambiare algoritmo. Oracle ha lavorato affinché, negli scenari in cui prima veniva scelto il Serial Collector, le metriche chiave — throughput, latenza, footprint di memoria e tempo di avvio — non peggiorino in modo significativo con G1.

# Comportamento fino a Java 26 (dipendente dall'ambiente): #   ambienti "server-class"  -> G1 automaticamente #   ambienti più piccoli     -> possibile Serial GC automatico   # Da Java 27, se non specifichi nulla: java -jar app.jar                     # G1 sempre, in ogni ambiente   # Per tornare esplicitamente al comportamento precedente (se necessario): java -XX:+UseSerialGC -jar app.jar

Per chi distribuisce applicazioni Java in container piccoli o su edge device, questa novità merita un test di carico dedicato prima dell’adozione in produzione: se l’applicazione girava finora su Serial GC in modo implicito, è opportuno verificare footprint di memoria e tempi di avvio con G1 prima di generalizzare l’upgrade.

4. Concorrenza strutturata: task paralleli senza caos (JEP 533)

Continuiamo la Guida Java 27. La concorrenza strutturata affronta un problema molto concreto: quando un metodo lancia più sotto-task in thread separati (per esempio due chiamate a servizi remoti da eseguire in parallelo), la gestione manuale di cancellazione, timeout ed eccezioni diventa rapidamente fragile e difficile da osservare. L’analogia utile è quella di una missione con più squadre sul campo: se il comando centrale annulla la missione, tutte le squadre devono saperlo e rientrare, non continuare a operare per conto proprio. Con l’API StructuredTaskScope, i sotto-task restano vincolati al ciclo di vita dello scope che li ha creati: se lo scope viene chiuso o cancellato, i sotto-task vengono cancellati con esso, e la gerarchia dei thread resta visibile agli strumenti di osservabilità.

Arrivata alla settima anteprima con la JEP 533, la concorrenza strutturata compie in Java 27 un passo importante verso la stabilizzazione: i “joiner” standard (come allSuccessfulOrThrow) non lanciano più l’eccezione specifica delle anteprime precedenti (FailedException), ma la classica ExecutionException, già nota a chiunque abbia lavorato con Future e ExecutorService. L’interfaccia StructuredTaskScope guadagna inoltre un terzo parametro di tipo per rappresentare il tipo di eccezione che join() può sollevare, migliorando la sicurezza dei tipi a compile-time.

Ecco un esempio semplificato di due chiamate remote eseguite in parallelo e unite come una singola unità di lavoro (richiede l’esecuzione con –enable-preview, trattandosi ancora di una feature in anteprima):

import java.util.concurrent.StructuredTaskScope; import java.util.concurrent.StructuredTaskScope.Joiner;   // Esegue due chiamate remote in parallelo e attende entrambe, // propagando automaticamente cancellazione ed eccezioni try (var scope = StructuredTaskScope.open(         Joiner.<String>allSuccessfulOrThrow())) {       var utente   = scope.fork(() -> servizioUtenti.recupera(idUtente));     var catalogo = scope.fork(() -> servizioCatalogo.recupera(idProdotto));       scope.join(); // attende entrambi i sotto-task come unità unica       // Se siamo qui, entrambe le chiamate sono andate a buon fine     componiRisposta(utente.get(), catalogo.get());   } catch (java.util.concurrent.ExecutionException e) {     // Da JEP 533: eccezione standard, non più specifica dell'anteprima     gestisciErrore(e.getCause()); }

Il vantaggio non è solo sintattico: eliminare la gestione manuale di cancellazione e timeout riduce due categorie di bug molto comuni nei sistemi concorrenti, i thread leak (thread che restano attivi dopo che il chiamante ha smesso di interessarsi al risultato) e i ritardi di cancellazione, particolarmente insidiosi nei sistemi cloud-native che devono scalare rapidamente e liberare risorse altrettanto rapidamente.

5. Vector API: calcolo vettoriale ad alte prestazioni (JEP 537) – Guida Java 27

La Vector API, giunta alla dodicesima incubazione con la JEP 537, permette di esprimere calcoli vettoriali in Java che vengono compilati a runtime nelle istruzioni SIMD ottimali disponibili sulla CPU in uso (per esempio AVX su x86 o SVE su ARM), senza dover scrivere codice nativo specifico per ogni architettura. L’analogia più immediata è quella di un magazziniere che invece di spostare una scatola alla volta ne sposta contemporaneamente otto o sedici con un unico movimento del muletto: stesso lavoro complessivo, molte meno operazioni per completarlo.

Questo si traduce in un vantaggio prestazionale misurabile per carichi di lavoro di analisi dati, inferenza AI e calcolo scientifico, dove le stesse operazioni vengono ripetute su grandi quantità di numeri. Java 27 introduce anche ottimizzazioni interne, come una nuova implementazione del prodotto scalare basata su operazioni fused multiply-add, che migliorano ulteriormente le prestazioni degli algoritmi vettoriali già esistenti.

Un esempio minimale di somma vettoriale (anche questa è una API incubator, va abilitata esplicitamente e richiede il modulo jdk.incubator.vector):

import jdk.incubator.vector.FloatVector; import jdk.incubator.vector.VectorSpecies;   public class SommaVettoriale {     static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;       static void somma(float[] a, float[] b, float[] risultato) {         int i = 0;         int limite = SPECIES.loopBound(a.length);           // Elabora più elementi per iterazione, sfruttando le istruzioni SIMD         for (; i < limite; i += SPECIES.length()) {             var va = FloatVector.fromArray(SPECIES, a, i);             var vb = FloatVector.fromArray(SPECIES, b, i);             va.add(vb).intoArray(risultato, i);         }           // Coda scalare per gli elementi residui         for (; i < a.length; i++) {             risultato[i] = a[i] + b[i];         }     } }

Per gli sviluppatori impegnati in inferenza AI lato JVM (per esempio nella fase di pre- o post-processing di embedding e feature numeriche, o in libreria di calcolo scientifico), la Vector API rappresenta oggi una delle strade più concrete per ottenere prestazioni vicine al codice nativo restando interamente dentro l’ecosistema Java.

6. Codifica PEM degli oggetti crittografici (JEP 538) – Guida Java 27

Chiunque abbia gestito certificati TLS conosce il formato PEM: blocchi di testo delimitati da intestazioni come —–BEGIN CERTIFICATE—– e —–END CERTIFICATE—–, ampiamente usato da autorità di certificazione, server web e strumenti come OpenSSL. Fino a oggi, però, l’API standard di Java non offriva un modo diretto per leggere o scrivere questo formato: gli sviluppatori dovevano rimuovere manualmente intestazioni e a capo, decodificare il Base64 residuo e ricostruire l’oggetto con le classi KeyFactory o CertificateFactory — un procedimento fragile, facile da sbagliare e poco portabile tra progetti.

La JEP 538, alla terza anteprima, introduce le classi PEMEncoder e PEMDecoder per colmare questa lacuna in modo nativo, riducendo il rischio di errori di parsing e semplificando la conformità nei contesti regolamentati che richiedono una gestione tracciabile di chiavi e certificati:

import java.security.PublicKey; import java.security.cert.X509Certificate;   // Decodifica una chiave pubblica PEM in un oggetto Java String pemChiave = """     -----BEGIN PUBLIC KEY-----     MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDrYzJwsz8uI...     -----END PUBLIC KEY-----     """;   PublicKey chiavePubblica = PEMDecoder.of().decode(pemChiave, PublicKey.class);   // Codifica un certificato X.509 esistente in formato PEM X509Certificate certificato = ottieniCertificato(); String pemCertificato = PEMEncoder.of().encodeToString(certificato);

Trattandosi di classi thread-safe e riutilizzabili, PEMEncoder e PEMDecoder si prestano bene a essere condivisi come componenti singleton nei servizi che gestiscono grandi volumi di certificati, per esempio nei sistemi di gestione delle identità o nei microservizi che ruotano automaticamente chiavi TLS in ambienti cloud-native.

7. Un ecosistema sincronizzato: Helidon, JavaFX, Jipher e Java Verified Portfolio

Entriamo nel vivo della Guida Java 27. Una delle novità meno tecniche ma più significative di Java 27 riguarda il modo in cui l’intero ecosistema Oracle si muove ora insieme al JDK. Introdotto a JavaOne 2026, il Java Verified Portfolio (JVP) raggruppa un insieme di tecnologie supportate da Oracle e allineate al ritmo di rilascio di OpenJDK, offrendo ai clienti della Oracle Java SE Universal Subscription una roadmap più prevedibile.

Helidon 27, il framework Oracle per microservizi cloud-native, adotta ora il cosiddetto modello Tip & Tail: Helidon 27 rappresenta la punta avanzata allineata a JDK 27, mentre Helidon 4.5.5 continua a essere mantenuto con versionamento semantico tradizionale per chi ha bisogno di maggiore stabilità. Helidon continua a puntare sui virtual thread per costruire servizi altamente concorrenti con codice più semplice.

JavaFX 27 porta miglioramenti al motore di rendering su macOS (la nuova pipeline Metal), controlli di editing testuale più ricchi e ulteriori miglioramenti di accessibilità, restando la scelta di riferimento per dashboard analitiche, console operative e strumenti di visualizzazione dati anche in contesti aziendali guidati dall’AI.

Oracle Jipher 20, infine, incapsula un modulo crittografico OpenSSL validato FIPS 140-3 per applicazioni Java, ed entra a far parte del Java Verified Portfolio. Aggiunge supporto per gli algoritmi post-quantistici ML-KEM e ML-DSA, funzioni di derivazione delle chiavi KDF e HKDF tramite le API standard di Java, e un’integrazione basata su Foreign Function & Memory (FFM) con OpenSSL, disponibile dalla base di JDK 25. Per i team che devono rispettare requisiti normativi stringenti (settore finanziario, difesa, pubblica amministrazione), avere un percorso di conformità FIPS ufficialmente supportato da Oracle semplifica sensibilmente gli audit di sicurezza.

8. Le altre JEP di Java 27 in sintesi – Guida Java 27

Oltre alle cinque JEP descritte finora, Java 27 introduce altre quattro proposte di miglioramento che completano il quadro delle nove novità principali della release.

JEP 532 Primitive Types in Patterns, instanceof e switch (Quinta Preview). Rimuove diverse restrizioni che finora impedivano l’uso di tipi primitivi nel pattern matching, in instanceof e negli switch, rendendo il linguaggio più uniforme ed espressivo. La release affina anche la definizione di “esattezza incondizionata” e introduce controlli di dominanza più rigorosi negli switch, permettendo al compilatore di individuare più errori di programmazione già in fase di compilazione.

JEP 534 Compact Object Headers by Default. Rende predefinito nella JVM HotSpot un formato compatto per l’intestazione degli oggetti, che scende da 96 a 64 bit sulle architetture a 64 bit. Il beneficio pratico è un heap più piccolo a parità di oggetti allocati, con conseguente maggiore densità di deployment e migliore località dei dati in memoria — un vantaggio diretto per chi esegue molte istanze JVM per container, come tipico nei microservizi.

JEP 531 Lazy Constants (Terza Preview). Introduce una API per costanti a inizializzazione ritardata: oggetti che contengono dati non modificabili, trattati dalla JVM come vere costanti con le stesse ottimizzazioni prestazionali di un campo final, pur potendo essere inizializzati più tardi rispetto alla dichiarazione. È particolarmente utile per applicazioni AI e data-driven, dove alcune risorse costose da inizializzare (per esempio un modello o una configurazione) devono essere pronte solo al primo utilizzo effettivo, favorendo avvii più rapidi e un uso più efficiente delle risorse di calcolo.

JEP 536 JFR In-Process Data Redaction. Estende Java Flight Recorder in modo che argomenti da riga di comando e valori iniziali di variabili d’ambiente e proprietà di sistema vengano oscurati prima ancora di lasciare il processo osservato. Questo riduce il rischio che informazioni sensibili (password, token, chiavi) finiscano accidentalmente in file diagnostici condivisi con team di supporto o strumenti di monitoraggio esterni.

9. Java 27 al servizio dei carichi di lavoro AI e degli agenti intelligenti – Guida Java 27

Pur non introducendo una API dedicata all’intelligenza artificiale, Java 27 è costruita con un’attenzione esplicita ai carichi di lavoro AI, ed è utile leggere in questa chiave diverse delle novità già descritte. La concorrenza strutturata (JEP 533) è la base naturale per orchestrare agenti AI che devono interrogare in parallelo più modelli, strumenti (tool) o servizi esterni e comporne le risposte come un’unica unità di lavoro: uno scenario sempre più comune in applicazioni che integrano librerie come LangChain4j o Spring AI, dove un agente deve invocare più tool contemporaneamente rispettando timeout e criteri di cancellazione condivisi.

La Vector API (JEP 537) accelera le fasi di calcolo numerico intensivo che precedono o seguono l’inferenza vera e propria, normalizzazione di embedding, similarità coseno, pre-processing di feature, permettendo di restare nella JVM invece di delegare questi passaggi a componenti nativi esterni. Le Lazy Constants (JEP 531) aiutano a contenere i tempi di avvio dei servizi che caricano modelli, indici vettoriali o configurazioni pesanti solo al primo utilizzo, un requisito frequente nelle architetture serverless e nei microservizi AI-enabled che devono scalare rapidamente. Infine, l’evoluzione del pattern matching sui tipi primitivi (JEP 532) semplifica la scrittura di codice che manipola strutture dati eterogenee tipiche delle pipeline di inferenza, dove i risultati di un modello possono assumere forme diverse a seconda del contesto.

Il messaggio di fondo per chi progetta sistemi AI-enabled in Java è che non serve un framework AI specifico per iniziare a beneficiare di Java 27: le fondamenta di concorrenza, calcolo numerico e gestione della memoria della piattaforma sono già orientate a questi scenari, e framework come Helidon, allineati al Java Verified Portfolio, iniziano a incorporare esplicitamente supporto per applicazioni AI-enabled.

10. Best practice per iniziare un progetto con Java 27 – Guida Java 27

Prima di adottare Java 27 in un nuovo progetto o in un aggiornamento importante, è utile seguire alcuni accorgimenti pratici che riducono il rischio di sorprese in produzione:

  • Valutare LTS vs non-LTS: per sistemi di produzione critici a lungo termine, Java 25 (LTS) resta il riferimento più prudente; Java 27 è ideale per ambienti di sperimentazione, proof of concept e progetti che possono seguire il ritmo semestrale delle release.
  • Abilitare le feature in anteprima solo in ambienti controllati: –enable-preview va usato in sviluppo e test, mai in produzione, perché le API di anteprima (come StructuredTaskScope o la Vector API) possono ancora cambiare tra una release e l’altra.
  • Aggiornare la toolchain prima del codice: plugin Maven/Gradle, IDE, analizzatori statici e strumenti di build devono dichiarare compatibilità con Java 27 prima di migrare i sorgenti.
  • Verificare le dipendenze crittografiche: chi utilizza librerie di terze parti per TLS o gestione di chiavi (es. Bouncy Castle) dovrebbe valutare se le nuove API native (PEM, post-quantum) permettono di semplificare o rimuovere alcune dipendenze esterne.
  • Testare l’impatto di G1 come default: se l’applicazione girava su ambienti con Serial GC selezionato automaticamente, eseguire test di carico dedicati su footprint di memoria, latenza e tempo di avvio prima di generalizzare l’aggiornamento.
  • Introdurre le nuove funzionalità in modo incrementale: adottare concorrenza strutturata e Vector API prima su moduli isolati e non critici, misurando benefici reali prima di estenderli all’intera codebase.
  • Investire nella formazione del team: la conoscenza di Java 8 o 11 non è sufficiente per usare correttamente virtual thread, pattern matching avanzato o concorrenza strutturata; sono paradigmi che richiedono uno studio dedicato.
  • Seguire le fonti ufficiali a ogni ciclo semestrale: monitorare le release notes Oracle e l’indice delle JEP permette di pianificare l’adozione delle novità con anticipo, invece di scoprirle a release già avvenuta.

11. Conclusioni: la formazione continua come vantaggio competitivo

La Guida Java 27 dimostra ancora una volta che il linguaggio più diffuso nelle organizzazioni enterprise non si limita a mantenersi al passo: prova ad anticipare le esigenze future, dalla sicurezza post-quantistica al supporto nativo per i carichi di lavoro AI, mantenendo al tempo stesso una disciplina di rilascio semestrale che in diciotto cicli consecutivi non ha mai sgarrato. Per i team di sviluppo, questo significa una cosa molto concreta: la piattaforma su cui hanno costruito la propria carriera continua a evolvere, e chi si ferma alla conoscenza di qualche versione fa più fatica a restare competitivo sul mercato del lavoro e nella qualità delle soluzioni che propone ai propri clienti.

Restare aggiornati su concorrenza strutturata, calcolo vettoriale, crittografia post-quantistica e sull’integrazione crescente tra Java e intelligenza artificiale non è più un’attività facoltativa per chi vuole guidare progetti tecnici solidi: è parte integrante del mestiere. Per questo motivo, investire in una formazione continua e strutturata rappresenta oggi uno dei modi più efficaci per trasformare l’aggiornamento tecnologico in un vantaggio competitivo reale, sia per lo sviluppatore che per l’azienda in cui lavora.

Formati con Innovaformazione: corsi Oracle Java e AI Generativa

Innovaformazione affianca sviluppatori, team IT e aziende italiane nell’aggiornamento tecnico continuo, con percorsi formativi pensati per portare le competenze del team allo stesso passo delle release ufficiali Oracle.

Per chi vuole consolidare o aggiornare le competenze Java, dal linguaggio di base fino alle funzionalità più recenti come quelle descritte in questo articolo, sono disponibili i corsi Oracle Java a catalogo.

Per i team che vogliono integrare l’intelligenza artificiale generativa nei propri progetti software — dall’uso di modelli linguistici alla progettazione di agenti AI, sono disponibili i corsi di AI Generativa per sviluppatori.

Contatti

Per informazioni sui percorsi formativi, programmi personalizzati per il tuo team o un preventivo su misura, contatta direttamente Dario Carrassi:

  • Email: info@innovaformazione.net
  • Telefono: 347 1012275 Dario Carrassi

Per altri articoli di settore consigliamo di navigare sul nostro blog dal seguente LINK.

(fonte) (fonte) (fonte)

Ti potrebbe interessare

Articoli correlati