Lors de la conférence Devoxx 2024, Jean-Michel Doudoux, éminent Java Champion, a captivé l’audience avec sa présentation sur les nouveautés de Java 21. Parmi les nombreuses JEP abordées, certaines se distinguent par leur potentiel à transformer le développement Java. Cet article mettra en lumière deux d'entre elles, en explorant leurs fonctionnalités et leur impact sur la communauté des développeurs. En particulier, la JEP 431 sur les collections séquencées et la JEP 444 sur les threads virtuels ont retenu mon attention pour leurs innovations prometteuses. Plongeons dans ces améliorations et voyons comment elles peuvent enrichir notre expérience de développement avec Java 21.

I. Sequenced Collections (JEP 431)

La JEP 431 introduit les collections séquencées, une nouvelle fonctionnalité de Java 21 qui vise à améliorer la manipulation des collections en fournissant un ordre de rencontre défini. Cette amélioration est particulièrement utile pour les développeurs travaillant avec des structures de données où l’ordre des éléments est crucial.

1-  Fonctionnalités Principales :

1.1  Interfaces Séquencées :

La JEP 431 propose de nouvelles interfaces telles que SequencedCollection, SequencedSet, et SequencedMap. Ces interfaces étendent les interfaces existantes (Collection, Set, Map) en ajoutant des méthodes permettant d’accéder aux premiers et derniers éléments, ainsi que pour traiter les éléments dans l’ordre inverse.

1.2  Accès Uniforme :

Grâce aux collections séquencées, il devient plus facile d’accéder de manière uniforme aux éléments d’une collection. Par exemple, les méthodes getFirst() et getLast() permettent d’accéder directement aux premiers et derniers éléments d’une collection, respectivement.

1.3  Manipulation de l’Ordre :

Les nouvelles méthodes telles que reversed() permettent de créer une vue inversée de la collection, facilitant ainsi les opérations nécessitant un traitement dans l’ordre inverse.

Pour parcourir une collection dans l’ordre inverse, les collections séquencées offrent une méthode directe avec reversed(), contrairement aux collections traditionnelles où il faut souvent utiliser des itérateurs ou des listes temporaires.

2-    Exemple :

Voici un exemple simple montrant comment utiliser les collections séquencées en Java 21 :

SequencedSet<String> sequencedSet = new LinkedHashSet<>() ;
sequencedSet.add("A");
sequencedSet.add("B");
sequencedSet.add("C");

System.out.println("First Element: " + sequencedSet.getFirst()); // Output: A
System.out.println("Last Element: " + sequencedSet.getLast()); // Output: C

SequencedSet<String> reversedSet = sequencedSet.reversed();
System.out.println("Reversed Set: " + reversedSet); // Output: [C, B, A]

3- Conclusion

La JEP 431 apporte une avancée significative pour les développeurs Java en introduisant des collections séquencées. Ces nouvelles interfaces simplifient l’accès et la manipulation des éléments dans un ordre défini, rendant le code à la fois plus intuitif et performant.

II. Virtual Threads (JEP 444)

La JEP 444, faisant partie du projet Loom, introduit les threads virtuels en Java 21. Cette fonctionnalité révolutionne la gestion des threads en offrant une alternative légère et scalable aux threads traditionnels, ce qui peut améliorer le débit des applications lorsque le nombre de tâches simultanées est important et que celles-ci ne nécessitent pas une utilisation intensive du CPU.

1-  Fonctionnalités Principales :

1.1  Légèreté :

 Contrairement aux threads traditionnels, les threads virtuels sont extrêmement légers. Ils consomment moins de ressources système, ce qui permet de créer des milliers, voire des millions de threads sans surcharger la JVM.

1.2  Scalabilité :

Les threads virtuels améliorent la scalabilité des applications en permettant une gestion plus efficace des tâches concurrentes. Cela est particulièrement utile pour les applications serveur qui doivent gérer de nombreuses connexions simultanées.

1.3  Facilité d’utilisation :

Les threads virtuels sont intégrés de manière transparente dans l’API de threading existante de Java. Les développeurs peuvent utiliser les mêmes abstractions et outils qu’ils connaissent déjà, sans avoir à apprendre de nouvelles API complexes.

2-  Exemple :

Dans cet exemple, nous créons un exécuteur de tâches qui utilise des threads virtuels pour exécuter 1000 tâches concurrentes. Chaque tâche imprime simplement un message indiquant qu’elle est en cours d’exécution.

3-  Détails Techniques :

Lorsque les threads virtuels exécutent des actions bloquantes dans les API du JDK, la JVM enregistre la pile d’exécution dans le tas (heap) et exécute l’action de manière non bloquante. Cela permet au thread porteur de continuer à exécuter d’autres threads virtuels. Une fois l’action non bloquante terminée, le traitement du thread virtuel reprend, potentiellement sur un thread porteur différent.

Cependant, certains scénarios bloquants peuvent limiter l’efficacité des threads virtuels, car ils restent associés à leur thread porteur :

• L’exécution d’un bloc de code synchronized (il est préférable d’utiliser un ReentrantLock si possible).

• L’exécution d’une méthode native.

• Pour identifier ces cas, vous pouvez utiliser l’option JVM suivante :

• -Djdk.tracePinnedThreads=full ou short

• Un événement JFR (JDK Flight Recorder) est également disponible :

• jdk.VirtualThreadPinned

La classe finale package-private java.lang.VirtualThread est utilisée pour créer des threads virtuels. La méthode la plus simple pour démarrer un thread virtuel est Thread::startVirtualThread :

L’interface scellée Thread.Builder propose deux sous-interfaces :

• Thread.Builder.OfVirtual

• Thread.Builder.OfPlatform

Vous pouvez obtenir une instance de ces interfaces avec Thread::ofVirtual et Thread::ofPlatform.

4- Restrictions des Thread Virtuels :

Les threads virtuels ont plusieurs restrictions :

• Ils sont obligatoirement des threads démons.

• Leur priorité est fixée à Thread.NORM_PRIORITY.

• Les méthodes stop(), resume() lèvent une UnsupportedOperationException.

• Ils ne peuvent pas être associés à un ThreadGroup.

• getThreadGroup() renvoie un groupe fictif « VirtualThreads » qui est vide.

• getAllStackTraces() renvoie une Map contenant uniquement les threads de l’OS plutôt que tous les threads.

5- Impact sur le Développement :

Les threads virtuels simplifient la création d’applications concurrentes en éliminant de nombreuses complexités associées aux threads traditionnels. Ils permettent aux développeurs de se concentrer sur la logique métier sans se soucier des détails de gestion des threads. De plus, les threads virtuels améliorent la performance et la scalabilité des applications, rendant Java encore plus puissant pour les applications modernes.

6- Conclusion

La JEP 444 est une avancée majeure pour le développement concurrent en Java. En introduisant des threads virtuels légers et scalables, cette JEP permet de créer des applications plus performantes et plus faciles à maintenir. Les développeurs peuvent ainsi tirer parti de la puissance de la concurrence sans les inconvénients des threads traditionnels, ouvrant la voie à des applications plus robustes et efficaces.

III. Conclusion générale :

Dans cet article, nous avons exploré deux des JEP les plus prometteuses de Java 21 : les Sequenced Collections (JEP 431) et les Virtual Threads (JEP 444).

Ces améliorations apportent des fonctionnalités puissantes et innovantes qui simplifient la gestion des collections et améliorent la concurrence dans les applications Java. En adoptant ces nouvelles fonctionnalités, les développeurs peuvent écrire du code plus propre, plus efficace et plus performant.

Java 21 introduit de nombreuses autres JEP intéressantes qui méritent également notre attention. Dans de futurs articles, nous continuerons à explorer ces nouvelles propositions d’amélioration pour vous aider à tirer le meilleur parti de cette version passionnante de Java.

 IV. Références

JEP431 : https://openjdk.org/jeps/431

JEP444 : https://openjdk.org/jeps/444

Devoxx Les nouveautés de Java 21 : https://www.youtube.com/watch?v=3Erjl1862Q4