Raisons de passer à Java 25

Java 25 est une version de support à long terme (LTS), qui en fait la cible naturelle pour les équipes qui s’exécutent sur Java 8, 11, 17 ou 21 aujourd’hui. Chaque version LTS reçoit des années de mises à jour et de correctifs de sécurité, ce qui permet de passer à Java 25 maintient vos applications prises en charge, sécurisées et capables d’utiliser les dernières améliorations en termes de performances et de langage.

La question n’est pas si vous devez passer à une version LTS plus récente, mais quand. Plus vous attendez, plus les modifications s’accumulent entre votre version actuelle et la suivante prise en charge. Il existe des avantages clairs pour passer à Java 25 et planifier le déplacement plus tôt que plus tard réduit les risques.

Depuis Java 8, chaque version a ajouté des fonctionnalités et des améliorations. Il existe des ajouts et des modifications notables de l’API, ainsi que des améliorations apportées au temps de démarrage, au débit, à l’utilisation de la mémoire, à la scalabilité et à la productivité des développeurs. Cet article met en évidence les changements les plus impactants, avec un focus sur les versions Java fournies depuis la version Java 11 LTS : Java 17, Java 21 et Java 25.

Transition vers Java 25

Vous pouvez passer à Java 25 de manière pas à pas. Le code développé et généré avec un JDK plus ancien peut généralement s’exécuter sur Java 25 sans recompilation. Comme pour toute mise à niveau majeure, surveillez les API supprimées, les packages déconseillés, l’utilisation d’API internes et les modifications apportées au comportement par défaut, en particulier autour du garbage collection.

Si vous venez de Java 8 ou 11, commencez par le guide sur la transition de Java 8 à Java 11 afin de traiter le plus grand nombre de changements majeurs incompatibles, puis poursuivez vers Java 17, 21 et 25. Si vous utilisez déjà Java 17 ou 21, la migration vers Java 25 est généralement plus simple, car le système de modules et la plupart des changements apportés à la plateforme sont déjà derrière vous.

Tip

GitHub application Copilot modernisation peut vous aider à évaluer votre application, à planifier la mise à niveau et à appliquer automatiquement des modifications de code. Il prend en charge les mises à niveau entre Java versions 8, 11, 17, 21 et 25, les builds et les tests de votre projet après chaque modification et aide à corriger les modifications de comportement décrites plus loin dans cet article.

Tip

Les indicateurs JVM qui ont été paramétrés pour un JDK plus ancien peuvent devenir dépréciés, supprimés ou non optimaux sur Java 25. Au lieu de transporter des paramètres obsolètes, vous pouvez laisser le lanceur de commandes Azure pour Java (jaz) appliquer automatiquement des indicateurs JVM adaptés à la version JDK et à vos ressources de conteneur ou de machine virtuelle. Remplacez la commande java par jaz dans votre script de lancement, ou Dockerfile pour en bénéficier.

Changements de haut niveau depuis Java 11

Cette section n'énumère pas toutes les modifications apportées depuis Java 8. Il met en évidence les changements qui ont le plus d’impact sur les performances, l’extensibilité, les diagnostics, la productivité et la sécurité. La plupart de ces fonctionnalités sont arrivées dans les versions Java 17, 21 et 25 et font désormais partie de la base de référence LTS que vous obtenez avec Java 25. Chaque fonctionnalité note la version Java dans laquelle elle a été intégrée.

Scalabilité avec des threads virtuels

Les threads virtuels [1] sont des threads légers, gérés par la machine virtuelle JVM plutôt que par le système d’exploitation, ce qui réduit considérablement le coût d’écriture et d’exécution d’applications simultanées à haut débit. Avec les threads virtuels, vous pouvez écrire du code selon un modèle simple d’un thread par requête, tout en passant à l’échelle pour prendre en charge un grand nombre d’opérations concurrentes, ce qui est idéal pour les microservices tributaires des E/S et les charges de travail de type requête-réponse.

Les threads virtuels ont été finalisés dans Java 21. Java 24 a supprimé une limitation de clé en permettant aux threads virtuels de se synchroniser sans épingler leurs threads porteurs [2], ce qui améliore la scalabilité du code qui utilise synchronized des blocs.

Concurrence structurée et valeurs de portée

Les valeurs délimitées [3] fournissent un moyen sûr et efficace de partager des données immuables au sein et entre des threads, y compris des threads virtuels. Il s’agit d’une alternative moderne aux variables locales de thread qui fonctionnent bien avec le modèle thread par tâche.

La concurrence structurée [4] traite les groupes de tâches simultanées associées comme une seule unité de travail, ce qui simplifie la gestion des erreurs et l’annulation. Apparu pour la première fois en version préliminaire dans Java 21, il continue d’évoluer et s’associe naturellement aux threads virtuels.

Productivité linguistique

Une série d’améliorations du langage fournies entre Java 14 et Java 25 rendent le code plus concis, plus sûr et plus facile à lire :

Les expressions de commutateur [5] (Java 14) permettent switch de retourner une valeur et d’utiliser une syntaxe de flèche plus propre.
Correspondance de modèle pour instanceof [6] (Java 16) supprime la nécessité de casts explicites après une vérification de type.
Les records [7] (Java 16) modélisent des données immuables comme des vecteurs transparents pour un ensemble fixe de valeurs, ce qui réduit le code répétitif.
Les classes scellées [8] (Java 17) vous permettent de contrôler les classes qui peuvent étendre ou implémenter un type.
Les blocs de texte [9] (Java 15) simplifient les littéraux de chaîne multiligne.
Le filtrage par motif pour switch [10] (Java 21) et les motifs d’enregistrement [11] (Java 21) vous permettent d’exprimer une logique conditionnelle complexe et la déstructuration des données de manière claire et sûre.
Les collections séquencées [12] (Java 21) ajoutent une API uniforme pour les collections avec un ordre de rencontre défini, y compris l’accès aux premiers et derniers éléments.
Les variables et les modèles non nommés [13] (Java 22) vous permettent de marquer explicitement les variables inutilisées et les composants de modèle.
Les déclarations d'importation de module [14] (Java 25) vous permettent d'importer les packages exportés d'un module entier avec une seule déclaration.
Les fichiers sources compacts et les méthodes principales d’instance [15] (Java 25) réduisent la cérémonie requise pour les petits programmes, ce qui rend Java plus facile à apprendre et à accélérer le prototype.
Les corps de constructeur flexibles [16] (Java 25) vous permettent d’exécuter des instructions avant d’appeler super(...) ou this(...), ce qui améliore la validation et l’initialisation.

Performances et démarrage

Plusieurs modifications du runtime améliorent le débit, l’empreinte mémoire et le temps de démarrage :

Les en-têtes d’objet compacts [17] (Java 25) réduisent la taille des en-têtes d’objet sur les plateformes 64 bits. Cette réduction réduit l’utilisation du tas et peut améliorer les performances des charges de travail nécessitant beaucoup d’allocation.
Le partage de données de classe (CDS) réduit le temps de démarrage en mappant en mémoire les classes archivées à l’exécution. Les archives CDS par défaut [18] (Java 12) et les archives CDS dynamiques [19] (Java 13) facilitent l’adoption de cette fonctionnalité sans exécutions manuelles de formation.
Chargement et liaison anticipés des classes [20] (Java 24), ainsi que l’ergonomie anticipée de la ligne de commande [21] (Java 25) et le profilage anticipé des méthodes [22] (Java 25), raccourcissent les temps de démarrage et de mise en régime en réutilisant le travail consigné dans une archive d’application. Ces fonctionnalités s’inscrivent dans le cadre des efforts du projet Leyden pour accélérer le démarrage de Java.

Ces améliorations sont particulièrement précieuses pour les charges de travail cloud-native et sans serveur, où un démarrage rapide et une empreinte réduite se traduisent directement par une meilleure mise à l’échelle et des coûts réduits.

Collecte des déchets

Java 25 est livré avec des ramasse-miettes éprouvés, à faibles temps de pause, adaptés à un large éventail de charges de travail :

ZGC [23] (Java 15) et Shenandoah [24] (Java 15) sont des collecteurs prêts pour la production conçus pour des temps de pause faibles sur les tas volumineux.
G1GC reste le collecteur par défaut et continue de recevoir des améliorations, notamment l’épinglage de région [25] (Java 22) pour une interaction plus fluide avec du code natif.
Le ZGC générationnel [26] (Java 21) améliore l’efficacité en conservant des générations distinctes. À compter de Java 23, ZGC s’exécute en mode générationnel par défaut [27], et le mode non générationnel a été supprimé dans Java 24.
Generational Shenandoah [28] (Java 25) ajoute un mode générationnel au collecteur Shenandoah pour améliorer le débit et la résilience sous pression de la mémoire.

La JVM configure les paramètres du GC par défaut pour un cas d’utilisation moyen. Ajustez ces paramètres par défaut et d’autres paramètres GC pour optimiser le débit ou la latence en fonction des exigences de votre application.

Tip

Le garbage collector par défaut et de nombreuses JVM par défaut diffèrent entre les versions de Java, de sorte que les paramètres paramétrés pour Java 8 ou 11 peuvent ne plus être optimaux sur Java 25. Le lanceur de commandes Azure pour Java (jaz) lit les limites de mémoire et d'UC du conteneur et applique automatiquement les indicateurs JVM adaptés à la version et à l'environnement JDK.

Diagnostics et observabilité

Les diagnostics se sont améliorés au fil des versions, à la fois dans le langage et dans Java Flight Recorder (JFR) :

Les nullPointerExceptions utiles [29] (Java 14) décrivent précisément quelle variable était null, ce qui accélère le débogage.
La diffusion en continu d’événements JFR [30] (Java 14) permet aux outils d’utiliser le profilage et les données de diagnostic en continu plutôt qu’à partir d’un fichier de vidage.
Le profilage JFR basé sur le temps processeur [31] (Java 25) ajoute un profilage expérimental des méthodes basé sur le temps processeur sous Linux.
L’échantillonnage coopératif JFR [32] (Java 25) améliore la stabilité de l’échantillonnage de pile.
Le minutage et le suivi des méthodes JFR [33] (Java 25) vous permettent de suivre et de timer des méthodes spécifiques sans modifier le code de l’application.

Sécurité et chiffrement

Java 25 renforce la posture de sécurité de la plateforme, y compris la préparation d'un monde post-quantique :

Algorithme de signature numérique à courbe d’Edwards (EdDSA) [34] (Java 15) introduit un schéma de signature moderne et très performant.
L’API mécanisme d’encapsulation de clé [35] (Java 21) fournit une API standard pour les algorithmes KEM.
Le chiffrement à résistance quantique ajoute des implémentations standard du mécanisme d’encapsulation de clé basée sur le module (ML-KEM) [36] (Java 24) et de l’algorithme de signature numérique (ML-DSA) [37] (Java 24).
L’API de fonction de dérivation de clé [38] (Java 25) fournit une API standard pour les fonctions de dérivation de clé.

Interopérabilité native

L’API de fonctions étrangères et de la mémoire [39] (Java 22) offre un moyen sûr, efficace et entièrement en Java d’appeler des bibliothèques natives et d’accéder à la mémoire native. Il s’agit d’un remplacement moderne de l’interface native Java (JNI) qui réduit le code répétitif et améliore la sécurité.

Outils et bibliothèques

Plusieurs ajouts améliorent le développement quotidien et réduisent le besoin d’outils tiers :

L’outil d’empaquetage (jpackage) [40] (Java 16) crée des programmes d’installation et des packages natifs pour les applications Java.
Le serveur web simple [41] (Java 18) fournit un serveur HTTP de fichier statique minimal pour le prototypage et le test.
Les générateurs de nombres pseudo-random améliorés [42] (Java 17) ajoutent de nouvelles interfaces et implémentations pour la génération de nombres aléatoires.

Changements de comportement à planifier

Certaines modifications depuis Java 11 modifient le comportement par défaut. Vérifiez-les donc avant de procéder à la mise à niveau :

Encapsuler fortement les composants internes du JDK [43] (Java 17) bloque par défaut l’accès par réflexion à la plupart des API internes. Le code ou les bibliothèques qui atteignent sun.* ou d’autres packages internes peuvent avoir besoin de mises à jour.
UTF-8 par défaut [44] (Java 18) rend UTF-8 l’ensemble de caractères par défaut pour les API de Java standard. Les applications qui s’appuyaient sur un charset par défaut spécifique à la plateforme peuvent se comporter différemment.
Déprécier la finalisation en vue de sa suppression [45] (Java 18) signale que finalize() finira par être supprimé. Migrer vers try-with-resources ou java.lang.ref.Cleaner.
Préparez-vous à interdire le chargement dynamique des agents [46] (Java 21) avertit lorsqu’un agent est chargé dans une machine virtuelle JVM en cours d’exécution. Certains outils de supervision et d’instrumentation peuvent nécessiter des modifications de configuration.

Tip

GitHub Copilot modernisation des applications peut vous aider à évaluer et corriger automatiquement ces changements de comportement lors de la mise à niveau.

Conteneurs et cloud

La prise en compte des conteneurs par la JVM, introduite pour Docker et d’autres environnements d’exécution de conteneurs, continue de s’améliorer. La machine virtuelle JVM lit les contraintes de processeur et de mémoire définies par les groupes de contrôle de conteneur (cgroups) et dimensionne le tas et d’autres ressources en conséquence. Combiné à un démarrage plus rapide, à une empreinte réduite et à des threads virtuels, Java 25 convient parfaitement aux déploiements en conteneur et serverless sur Azure.

Si vous exécutez des charges de travail Java sur des conteneurs ou des machines virtuelles dans Azure, le Azure Command Launcher for Java (jaz) peut appliquer pour vous des paramètres JVM par défaut optimisés pour le cloud et adaptés à la version.

Étapes suivantes

References

[1] Oracle Corporation, « JEP 444 : Threads virtuels ». (En ligne). Disponible : https://openjdk.org/jeps/444.

[2] Oracle Corporation, « JEP 491 : Synchroniser les fils d’exécution virtuels sans épinglage ». (En ligne). Disponible : https://openjdk.org/jeps/491.

[3] Oracle Corporation, « JEP 506 : Valeurs délimitées ». (En ligne). Disponible : https://openjdk.org/jeps/506.

[4] Oracle Corporation, « JEP 453 : Concurrence structurée (version préliminaire). » (En ligne). Disponible : https://openjdk.org/jeps/453.

[5] Oracle Corporation, « JEP 361 : Switch Expressions ». (En ligne). Disponible : https://openjdk.org/jeps/361.

[6] Oracle Corporation, « JEP 394 : Pattern Matching for instanceof ». (En ligne). Disponible : https://openjdk.org/jeps/394.

[7] Oracle Corporation, « JEP 395 : Enregistrements ». (En ligne). Disponible : https://openjdk.org/jeps/395.

[8] Oracle Corporation, « JEP 409 : Sealed Classes ». (En ligne). Disponible : https://openjdk.org/jeps/409.

[9] Oracle Corporation, « JEP 378 : Blocs de texte ». (En ligne). Disponible : https://openjdk.org/jeps/378.

[10] Oracle Corporation, « JEP 441 : Filtrage par motif pour switch. » (En ligne). Disponible : https://openjdk.org/jeps/441.

[11] Oracle Corporation, « JEP 440 : Modèles d’enregistrement ». (En ligne). Disponible : https://openjdk.org/jeps/440.

[12] Oracle Corporation, « JEP 431 : Collections séquencées ». (En ligne). Disponible : https://openjdk.org/jeps/431.

[13] Oracle Corporation, « JEP 456 : Variables et modèles non nommés ». (En ligne). Disponible : https://openjdk.org/jeps/456.

[14] Oracle Corporation, « JEP 511 : Déclarations d’importation de module ». (En ligne). Disponible : https://openjdk.org/jeps/511.

[15] Oracle Corporation, « JEP 512 : Compact Source Files and Instance Main Methods ». (En ligne). Disponible : https://openjdk.org/jeps/512.

[16] Oracle Corporation, « JEP 513 : Flexible Constructor Bodies ». (En ligne). Disponible : https://openjdk.org/jeps/513.

[17] Oracle Corporation, « JEP 519 : Compact Object Headers ». (En ligne). Disponible : https://openjdk.org/jeps/519.

[18] Oracle Corporation, « JEP 341 : Archives CDS par défaut ». (En ligne). Disponible : https://openjdk.org/jeps/341.

[19] Oracle Corporation, « JEP 350 : Dynamic CDS Archives ». (En ligne). Disponible : https://openjdk.org/jeps/350.

[20] Oracle Corporation, « JEP 483 : Chargement de classes à l’avance et liaison ». (En ligne). Disponible : https://openjdk.org/jeps/483.

[21] Oracle Corporation, « JEP 514 : ergonomie de la ligne de commande en avance de phase ». (En ligne). Disponible : https://openjdk.org/jeps/514.

[22] Oracle Corporation, « JEP 515 : Profilage des méthodes à l’avance ». (En ligne). Disponible : https://openjdk.org/jeps/515.

[23] Oracle Corporation, « JEP 377 : ZGC : A Scalable Low-Latency Garbage Collector ». (En ligne). Disponible : https://openjdk.org/jeps/377.

[24] Oracle Corporation, « JEP 379 : Shenandoah : A Low-Pause-Time Garbage Collector. » (En ligne). Disponible : https://openjdk.org/jeps/379.

[25] Oracle Corporation, « JEP 423 : Verrouillage de région pour G1 ». (En ligne). Disponible : https://openjdk.org/jeps/423.

[26] Oracle Corporation, « JEP 439 : Generational ZGC ». (En ligne). Disponible : https://openjdk.org/jeps/439.

[27] Oracle Corporation, « JEP 474 : ZGC : Mode générationnel par défaut ». (En ligne). Disponible : https://openjdk.org/jeps/474.

[28] Oracle Corporation, « JEP 521 : Generational Shenandoah. » (En ligne). Disponible : https://openjdk.org/jeps/521.

[29] Oracle Corporation, « JEP 358 : NullPointerExceptions utile ». (En ligne). Disponible : https://openjdk.org/jeps/358.

[30] Oracle Corporation, « JEP 349 : JFR Event Streaming ». (En ligne). Disponible : https://openjdk.org/jeps/349.

[31] Oracle Corporation, « JEP 509 : profilage JFR du temps processeur (expérimental). » (En ligne). Disponible : https://openjdk.org/jeps/509.

[32] Oracle Corporation, « JEP 518 : Échantillonnage coopératif JFR ». (En ligne). Disponible : https://openjdk.org/jeps/518.

[33] Oracle Corporation, « JEP 520 : JFR Method Timing &Tracing ». (En ligne). Disponible : https://openjdk.org/jeps/520.

[34] Oracle Corporation, « JEP 339 : Edwards-Curve Digital Signature Algorithm (EdDSA). » (En ligne). Disponible : https://openjdk.org/jeps/339.

[35] Oracle Corporation, « JEP 452 : API du mécanisme d’encapsulation de clé ». (En ligne). Disponible : https://openjdk.org/jeps/452.

[36] Oracle Corporation, « JEP 496 : Mécanisme d'encapsulation de clés fondé sur les réseaux de modules et résistant aux attaques quantiques. » (En ligne). Disponible : https://openjdk.org/jeps/496.

[37] Oracle Corporation, « JEP 497 : algorithme de signature numérique fondé sur les réseaux de modules et résistant aux attaques quantiques ». (En ligne). Disponible : https://openjdk.org/jeps/497.

[38] Oracle Corporation, « JEP 510 : API de fonction de dérivation de clé ». (En ligne). Disponible : https://openjdk.org/jeps/510.

[39] Oracle Corporation, « JEP 454 : Foreign Function &Memory API ». (En ligne). Disponible : https://openjdk.org/jeps/454.

[40] Oracle Corporation, « JEP 392 : Packaging Tool ». (En ligne). Disponible : https://openjdk.org/jeps/392.

[41] Oracle Corporation, « JEP 408 : Serveur web simple ». (En ligne). Disponible : https://openjdk.org/jeps/408.

[42] Oracle Corporation, « JEP 356 : Générateurs de nombres Pseudo-Random améliorés ». (En ligne). Disponible : https://openjdk.org/jeps/356.

[43] Oracle Corporation, « JEP 403 : Encapsuler fortement les éléments internes JDK ». (En ligne). Disponible : https://openjdk.org/jeps/403.

[44] Oracle Corporation, « JEP 400 : UTF-8 par défaut ». (En ligne). Disponible : https://openjdk.org/jeps/400.

[45] Oracle Corporation, « JEP 421 : Dépréciation de la finalisation en vue de sa suppression ». (En ligne). Disponible : https://openjdk.org/jeps/421.

[46] Oracle Corporation, « JEP 451 : Se préparer à interdire le chargement dynamique des agents ». (En ligne). Disponible : https://openjdk.org/jeps/451.

Last updated on 2026-06-16