En attendant la publication de Java 21, la prochaine version diffusée en septembre de cette année, et pour en donner quelques aperçus, cette présentation brosse une revue détaillée des nouveautés qui devraient être proposées dans cette future version LTS de Java, issues des projets Amber, Loom et Panama d’OpenJDK.

1. 1
Java en 2023
En route vers
Java 21
@jmdoudoux
JMdoudouX
1 juin 2023

2. Sciam
Java SE en 2023
2023, année importante
2
Java poursuit son évolution
En respectant le rythme de release tous les 6 mois
En 2022 : Java 18 en mars et Java 19 en septembre
Java 20 en mars et Java 21 en septembre
Java 21 est une version LTS
Depuis la réduction de 3 à 2 ans entre 2 LTS après Java 17

3. Sciam
Safe Harbor
Habituellement, je parle de sujets présents ou passés
3
Dans cette présentation, je parle de sujets futurs
Certes un futur proche : septembre 2023
Mais la période de freeze de Java 21 n’est pas encore commencée
On a déjà une bonne idée sur la majorité des fonctionnalités
Mais certaines peuvent encore évoluer

4. Sciam
Les travaux en cours pour Java 21
Les spécifications EN COURS dans la JSR 396
4
13 JEPs sont déjà ciblées (targeted) :
JEP 404 : Generational Shenandoah (Experimental)
JEP 430 : String Templates (Preview)
JEP 431 : Sequenced Collections
JEP 439 : Generational ZGC
JEP 440 : Record Patterns
JEP 441 : Pattern Matching for switch
JEP 442 : Foreign Function & Memory API (Third Preview)
JEP 443 : Unnamed Patterns and Variables (Preview)
JEP 444 : Virtual Threads
JEP 445 : Unnamed Classes and Instance Main Methods (Preview)
JEP 448 : Vector API (Sixth Incubator)
JEP 449 : Deprecate the Windows 32-bit x86 Port for Removal
3 JEPs sont proposées comme cibles (Proposed to targeted) :
JEP 453 : Structured Concurrency (Preview)
JEP 451 : Prepare to Disallow the Dynamic Loading of Agents
JEP 446 : Scoped Values (Preview)

5. Sciam 5
Jean-Michel Doudoux
https://www.jmdoudoux.fr
@jmdoudoux
Co-fondateur du
Auteur de 2 didacticiels
Diffusés sous licence GNU FDL
• Développons en Java (4000 pages)
• Développons en Java avec Eclipse
Senior Tech Lead
chez

6. Sciam
Roadmap
Les fonctionnalités
du projet Amber
6
Les évolutions
du projet Panama
du projet Loom
dans la JVM Hotspot
dans les API Java Core

7. Sciam
Les fonctionnalités
du projet Amber
Record Patterns
Pattern Matching for switch
String Templates (Preview)
Unnamed Patterns and Variables (Preview)
Unnamed Classes and Instance Main Methods (Preview)

8. Sciam
Record Patterns
En preview en Java 19 (JEP 420) et 20 (JEP 432)
8
Standard en Java 21
Type pattern utilisable avec le pattern matching sur les records
record Employe(String nom, String prenom) {}
Object o = new Employe("Nom1", "Prenom1");
if (o instanceof Employe emp) {
System.out.println("Employe : "+emp.nom()+" "+emp.prenom());
}
Ajouter un nouveau pattern utilisable dans le pattern matching
Le record pattern pour déconstruire les valeurs d’un record
if (o instanceof Employe(String nom, String prenom)) {
System.out.println("Employe : "+nom+" "+prenom);
}

9. Sciam
switch (o) {
case Employe emp -> System.out.println(emp);
case Grade(String code,String designation) -> System.out.println("Grade " + designation + "(" + code + ")");
default -> System.out.println("Type non supporté");
}
Record Patterns
Utilisable avec une instruction instanceof ou switch
Type pattern et record pattern peuvent être combinés
Dans un même switch
Java 20 : utilisable dans une boucle for améliorée
List<Employe> employes = List.of(new Employe("Nom1", "Prenom1"));
for(Employe(var nom, var prenom) : employes) {
System.out.println(nom + " " + prenom);
}
9
Java 21 : retiré

10. Sciam
Record Patterns
Le nom des variables peut être différents de celui des composants
Seuls l’ordre et le type des composants doivent être respectés
if (o instanceof Employe(String n, String p)) {
System.out.println("Employe : " + n + " " + p);
}
if (o instanceof Employe(var nom, var prenom)) {
System.out.println("Employe : "+nom+" "+prenom);
}
Utilisation possible de l’inférence du type dans le pattern
10
record Mono<T>(T val) implements Container<T> {}
Mono<Mono<String>> monoDeMono = new Mono<>(new Mono<>("valeur"));
Support de l'inférence des types d’arguments génériques
if (monoDeMono instanceof Mono(Mono(var s))) {
System.out.println("mono contient " + s);
}

11. Sciam
record Grade(String code, String designation) {}
record Employe(String nom, String prenom, Grade grade) {}
Object o = new Employe("Nom1", "Prenom1", new Grade("DEV", "Développeur"));
if (o instanceof Employe(var nom, var prenom, Grade(var code, var designation))) {
System.out.println("Employe : " + nom + " " + prenom + ", "+ designation);
}
Record Patterns
Les record patterns peuvent être imbriqués
La valeur null ne correspond à aucun record pattern
11

12. Sciam
Pattern Matching for switch
Historiquement 4 preview en Java
17 (JEP 406), 18 (JEP 420), 19 (JEP 427) et 20 (JEP 433)
But : utiliser le pattern matching dans une instruction switch
En maintenant la compatibilité syntaxique
Avec un support de la valeur null contrairement à la levée historique d’une NPE
12
static String getDesignation(Object obj) {
String designation = switch (obj) {
case Terrain t -> "Terrain";
case null -> "Instance null";
default -> "Pas un terrain";
};
return designation;
}
Standard en Java 21
Plusieurs patterns utilisables
Type pattern
Teste la correspondance sur un type

13. Sciam
Pattern Matching for switch
Guarded pattern case label
Combine un pattern et une expression booléenne
Utilise le nouveau mot clé contextuel when
13
static String getDesignation(Object obj) {
String designation = switch (obj) {
case Terrain t
when (t.getSurface() > 1000) -> "Grand terrain";
case Terrain t -> "Petit terrain";
case null -> "Instance null";
default -> "Pas un terrain";
};
return designation;
}
Record Pattern
Déconstruit un record
Parenthesized pattern retiré en Java 21

14. Sciam
Pattern Matching for switch
Possibilité de mixer constantes et patterns
14
L’exhaustivité des cas d’un switch doit être satisfaite
Sinon erreur de compilation : implique fréquemment l’utilisation d’un default
Au runtime une exception de type java.lang.MatchException est levée
Exemple : sur un type scellé ou une énumération par exemple
String getEnv(String env) {
return switch (env) {
case "Prod" -> "Production";
case String s -> "Hors production";
};
}
static String formater(Number nombre) {
return switch (nombre) { // erreur : the switch expression does not cover all possible input values
case Integer i -> String.format("int %d", i);
case Long l -> String.format("long %d", l);
}; }

15. Sciam
Pattern Matching for switch
Le compilateur vérifie la dominance des patterns
Les patterns les plus restrictifs doivent être avant les moins restrictifs
15
static String formater(Object o) {
return switch (o) {
case Number n -> String.format("number %f", n);
case Integer i -> String.format("int %d", i); // erreur this case label is dominated by a preceding case label
case Long l -> String.format("long %d", l);
default -> o.toString();
};
}
Idem avec les guarded patterns
String taille = switch (chaine) {
case String s -> "Moyenne";
case String s when s.length() < 10 -> "Petite"; // erreur this case label is dominated by a preceding case label
case String s when s.length() > 100 -> "Grande";
};

16. Sciam
Pattern Matching for switch
Sémantique d'exécution d’un switch avec le pattern matching
Lorsque la valeur est null et que le cas null n’est pas explicitement géré :
Elle est étroitement alignée sur la sémantique historique des switchs
16
public static void main(String[] args) {
String chaine = null;
switch (chaine) {
case String s -> {
System.out.println("traitement chaine");
System.out.println("taille : " + s.length());
}
}
}
Exception in thread "main" java.lang.NullPointerException
at java.base/java.util.Objects.requireNonNull(Objects.java:233)
at TestSwitchPattern.main(TestSwitchPattern.java:5)

17. Sciam
Java 21 autorise les constantes d'énumération qualifiées
Dans les cases des switchs afin d’éviter d’avoir à utiliser un guarded pattern
17
public sealed interface MonInterface permits MonEnum, MaClasse {}
public enum MonEnum implements MonInterface { PAIRE, IMPAIRE }
public final class MaClasse implements MonInterface {}
// …
static void traiter(MonInterface c) {
switch (c) {
// case MonEnum e when e == MonEnum.PAIRE -> { System.out.println("Paire"); }
case MonEnum.PAIRE -> { System.out.println("Paire"); }
case MonEnum.IMPAIRE -> { System.out.println("Impaire"); }
case MonEnum e -> { System.out.println("MonEnum"); }
case MaClasse mc -> { System.out.println("MaClasse"); }
}
}
Pattern Matching for switch

18. Sciam
String Templates (Preview)
Courant de devoir créer des chaînes de caractères composées
À partir d'une combinaison de textes littéraux
Et de valeurs ou d'expressions
18
Historiquement plusieurs fonctionnalités, toutes avec inconvénients
String s = x + " + " + y + " = " + (x + y);
MessageFormat mf = new MessageFormat("{0} + {1} = {2}");
String s = mf.format(x, y, x + y);
String s = String.format("%2$d + %1$d = %3$d", x, y, x + y);
String t = "%2$d + %1$d = %3$d".formatted(x, y, x + y);
String s = new StringBuilder()
.append(x)
.append(" + ")
.append(y)
.append(" = ")
.append(x + y)
.toString();
De nombreux langages proposent l'interpolation de chaînes
Comme alternative à la concaténation de chaînes

19. Sciam
String Templates (Preview)
La plupart des langages supportent l’interpolation de chaînes
Mais le résultat peut parfois engendrer des soucis indirects
Exemple : SQL ou JSON injection
19
En combinant :
- Un texte littéral avec des expressions intégrées
- Et un processeur de templates
Pour produire des chaînes de caractères construites dynamiquement
Avec la clarté de l’interpolation et un résultat plus sûr
Le but : enrichir le langage Java avec des string templates
Qui complètent les chaînes littérales et les blocs de texte
Possibilité de créer une instance de type quelconque
Avec un processeur de templates personnalisés

20. Sciam
String Templates (Preview)
Nouveau type d'expression dans le langage : les templates expressions
Pour effectuer une interpolation de chaîne pour créer une chaîne ou un objet
20
Syntaxiquement, ressemble à une chaîne littérale avec un préfixe :
String prenom = "Jean-Michel";
String message = STR."Bonjour {prenom}";
Une template expression est composée de trois éléments :
1) Un processeur de templates (STR)
2) Un caractère point (U+002E), celui utilisé dans les autres expressions
3) Un template ("Bonjour {prenom}")
qui contient une expression intégrée ({prenom})
Le template peut utiliser plusieurs lignes de code source
En utilisant une syntaxe similaire à celle des blocs de texte

21. Sciam
String Templates (Preview)
3 processeurs de templates dans le JDK
21
STR : effectue une interpolation pour créer une chaîne
int x = 10, y = 20;
String s = STR."{x} + {y} = {x + y}";
FMT : effectue une interpolation pour créer une chaîne
Il interprète les spécificateurs de format à gauche des expressions intégrées
Les spécificateurs de format sont ceux définis dans java.util.Formatter
RAW : produit un objet de type StringTemplate
String prenom = "Jean-Michel";
StringTemplate st = RAW."Bonjour {prenom}";
String message = STR.process(st);

22. Sciam
String Templates (Preview)
Possibilité de définir des processeurs de templates personnalisés
Pour générer des chaînes ou des objets qui peuvent être validés
22
Une instance de l'interface fonctionnelle StringTemplate.Processor
Implémenter l’unique méthode process()
Utilisation de la fabrique StringTemplate.Processor::of
Pour obtenir une instance
var JSON = StringTemplate.Processor.of((StringTemplate st) -> new JSONObject(st.interpolate()));
String nom = "Durant";
String prenom = "Pierre";
JSONObject doc = JSON."""
{
"nom": "{nom}",
"prenom": "{prenom}"
}""";

23. Sciam
Unnamed Patterns and Variables
(Preview)
Enrichit le langage d’une syntaxe
Pour les patterns inutilisés dans les records pattern imbriqués
Et les variables inutilisées qui doivent être déclarées
23
Unnamed pattern : un pattern inconditionnel qui ne correspond à rien
Utilisable dans un pattern imbriqué à la place d'un type ou record pattern
record Grade(String code, String designation) {}
record Employe(String nom, String prenom, Grade grade) {}
Object o = new Employe("Nom1", "Prenom1", new Grade("DEV", "Développeur"));
if (o instanceof Employe(var nom, var prenom, _)) {
System.out.println("Employe : " + nom + " " + prenom);
}
Utilisant le 51eme mot clé réservé de Java : _

24. Sciam
Unnamed Patterns and Variables
(Preview)
Unnamed pattern variable :
Utilisable avec tous types de patterns
24
Unnamed variable : peut être initialisée mais non utilisée dans
Une variable locale dans un bloc
Une ressource dans un try-with-resources
L'en-tête d'une boucle for et for améliorée
Une exception d'un bloc catch
Un paramètre formel d'une expression Lambda
try (var _ = ScopedContext.acquire()) {
var _ = service.traiter((_, _) -> System.out.printn("traiter"));
} catch (Throwable _) { }
if (o instanceof Employe(var nom, var _, _)) {
System.out.println("Employe : " + nom);
}
Utilisable plusieurs fois dans la même portée

25. Sciam
Unnamed Patterns and Variables
(Preview)
Utile dans des switchs avec des patterns sur des types scellés
25
void traiterFormeRonde(Forme forme) {
switch(forme) {
case Cercle c -> afficher(c);
case Carre c -> {}
case Rectangle r -> {}
}
}
switch(forme) {
case Cercle c -> afficher(c);
default -> {}
}
switch(forme) {
case Cercle c -> afficher(c);
case Carre _, Rectangle _ -> {}
}
Impossible d’avoir plusieurs patterns
nommés dans un case
Risque de bug en cas d’ajout d’un type :
sealed interface Forme permits Cercle, Carre, Rectangle {}
Utilisation possible de default
préférable d’utiliser des unnamed variables

26. Sciam
Unnamed Classes and Instance Main Methods
(Preview)
26
Plutôt compliqué
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello world");
}
}
Les buts :
Faire évoluer le langage pour simplifier les programmes simples
Et faciliter l’apprentissage des débutants avec le langage Java
Méthode d’instance main()
class HelloWorld {
void main() {
System.out.println("Hello world");
}
}
void main() {
System.out.println("Hello world");
}
Classe sans nom (unnamed class)
Deux évolutions dans une classe unique

27. Sciam
Les fonctionnalités du
projet Loom
Virtual Threads
Structured Concurrency (Preview)
Scoped Values (Preview)

28. Sciam
Le projet Loom
Le but : explorer, incuber et fournir des fonctionnalités (JVM et API)
Pour prendre en charge une concurrence légère, facile à utiliser et à haut débit
Après une longue attente
Et plusieurs fonctionnalités livrées en prérequis à partir de Java 13
28
3 premières fonctionnalités sont fournies :
• Les threads virtuels (preview)
• La concurrence structurée (incubation)
• Les Scoped values (incubation)
Ainsi que de nouveaux modèles de programmation concurrente
Devraient à terme permettre de réduire les efforts nécessaires
Pour écrire et maintenir des applications concurrentes à haut débit en Java

29. Sciam
Virtual Threads
Introduction d’un nouveau type de threads : des threads virtuels
Plusieurs objectifs :
29
Ce sont des threads « légers » gérés dans la JVM
Non lié à un thread de la plate-forme dédié
Qu’il utilise uniquement lors de l’utilisation de la CPU par ses traitements
• Assurer une adoption par le code existant
Qui utilise l'API java.lang.Thread avec un impact minimum
• Conserver le style « un thread par requête »
Avec une meilleure utilisation des ressources requises
• Permettre le débogage, le profilage et le dépannage
Avec les outils existants du JDK
En preview Java 19 (JEP 425) et 20 (JEP 436)

30. Sciam
Virtual Threads
Java 21 : devient une fonctionnalité standard
30
Une modification apportée suite aux feed backs
Cela facilitera la migration vers les threads virtuels
Des frameworks et du code existant
Support désormais permanent des variables thread-local
Il n’est plus possible de créer des threads virtuels
qui ne peuvent pas avoir de variables thread-local
Rémi

31. Sciam
Structured Concurrency (preview)
Propose un nouveau modèle de programmation
Grâce au traitement de plusieurs tâches
Exécutées dans différents threads virtuels comme une seule unité de travail
31
Le but : simplifier la programmation multithread
En rationalisant la gestion des erreurs et l'annulation,
En améliorant la fiabilité et en renforçant l'observabilité
Le modèle permet une écriture du code dans un style synchrone
Avec une exécution en asynchrone
Le code est ainsi facile à écrire, à lire et à tester
Rémi
En incubation Java 19 (JEP 428) et 20 (JEP 437)
En preview 21 (JEP 453 : proposed to target)

32. Sciam
Scoped Values (Preview)
Pour partager des objets dans le code exécuté par un thread
Historiquement depuis Java 1.2, on utilise une variable de type ThreadLocal
L’API ScopedValue tente de remédier à ces inconvénients
32
Mais cela présente plusieurs risques :
Mutable, fuite de mémoire, consommation de ressources,
public final static ScopedValue<String> VALEUR = ScopedValue.newInstance();
Création d’une instance généralement statique et publique
Stocker et de partager des données immuables
Pour une durée de vie limitée à des traitements du thread qui les a écrits
En incubation Java 20 (JEP 429)
En preview 21 (JEP 446 : proposed to target)

33. Sciam
Scoped Values (Preview)
where() pour définir une valeur, chainable pour plusieurs valeurs
get() pour obtenir la valeur ou lève une NoSuchElementException
33
Pour exécuter une tâche dans le thread courant
System.out.println((VALEUR.isBound() ? VALEUR.get() : "non definie"));
isBound() pour savoir si une valeur est associée au thread
run() : sous la forme d’une implémentation de Runnable
ScopedValue.where(VALEUR, "test").run(() -> { afficherValeur(); });
Ou call() : sous la forme d’une implémentation de Callable
String valeur = ScopedValue.where(VALEUR, "test")
.<String>call(monService::traiter);

34. Sciam
Scoped Values (Preview)
Réassociation d’une valeur pour un traitement sous-jacent
Partage avec les threads virtuels d’une StucturedTaskScope
34
ScopedValue.where(VALEUR, "valeur", () -> {
try (var scope = new StructuredTaskScope<String>()) {
afficherValeur();
scope.fork(monServiceA::traiter);
scope.fork(monServiceB::traiter);
scope.joinUntil(Instant.now().plusSeconds(10));
} catch (InterruptedException | TimeoutException e) {
e.printStackTrace();
}
});
ScopedValue.where(VALEUR, "valeur").run(() -> {
afficherValeur();
ScopedValue.where(VALEUR, "autre-valeur").run(monService::traiter);
afficherValeur();
});

35. Sciam
Les fonctionnalités
du projet Panama
JEP 442 : Foreign Function & Memory API (Third Preview)
JEP 448 : Vector API (Sixth Incubator)

36. Sciam
Foreign Function & Memory API
(Third Preview)
API de bas niveau pour de manière simple, sûre et efficace :
• Accéder à des données en mémoire hors du tas (off heap memory)
• Invoquer des fonctions natives
Proposée en preview en Java 19 (JEP 424), 20 (JEP 434) et 21
Elle est maintenant est dans le module java.base
36
Historiquement, fusion de 2 JEPs introduites en incubation :
Foreign-Memory Access API en Java 14 (JEP 370, 383, et 393)
Et Foreign Linker API en Java 16 (JEP 389)
Proposée en incubation en Java 17 (JEP 412) et Java 18 (JEP 419)
Attention : cette API évolue beaucoup
Dans chacune des versions de Java où elle est proposée

37. Sciam
L’API de bas niveau
2) Pour invoquer du code natif
Une future alternative à l’API JNI présente depuis Java 1.1
37
1) Pour accéder à des données
En mémoire hors du tas (off heap memory)
De manière sûre et performante
Alternative à certaines fonctionnalités
De java.nio.ByteBuffer (pas performante mais sûre)
Et sun.misc.Unsafe (non standard)
Foreign Function & Memory API
(Third Preview)

38. Sciam
public class DialogFFM {
public static void main(String[] args) {
try {
System.loadLibrary("user32");
Optional<MemorySegment> msgBoxFunction = SymbolLookup.loaderLookup().find("MessageBoxA");
FunctionDescriptor msgBoxFunctionDesc = FunctionDescriptor.of(JAVA_INT, ADDRESS, ADDRESS, ADDRESS, JAVA_INT);
Linker linker = Linker.nativeLinker();
MethodHandle methodHandle = linker.downcallHandle(msgBoxFunction.get(), msgBoxFunctionDesc);
try (Arena offHeap = Arena.ofConfined()) {
MemorySegment cStringMessage = offHeap.allocateUtf8String("Voulez-vous utiliser Java 21 ?");
MemorySegment cStringTitre = offHeap.allocateUtf8String("Confirmation");
int bouton = (int) methodHandle.invoke(NULL, cStringMessage, cStringTitre, 36);
}
} catch (Throwable t) {
t.printStackTrace();
}
}
}
38
Foreign Function & Memory API
(Third Preview)
Exemple Java 21 sous Windows

39. Sciam
Vector API (Sixth Incubator)
Exprimer des calculs vectoriels
Qui, au moment de l'exécution, sont systématiquement compilés
Avec les meilleures instructions vectorielles possibles sur l’architectures CPU
Les SIMD sur les CPU supportées : x64 (SSE et AVX) et AArch64 (Neon)
Dans le module jdk.incubator.vector
39
Single Instruction, Multiple Data
Traiter en parallèle un tableau de données, sans threads
Pour appliquer une même opération sur plusieurs valeurs traitées
En un seul cycle de traitement CPU
En incubation en Java 16 (JEP 338), 17 (JEP 414), 18 (JEP 417),
19 (JEP 426), 20 (JEP 438) et 21

40. Sciam
static float[] calculerScalaire(float[] a, float[] b) {
float[] c = new float[a.length];
for (int i = 0 ; i < a.length ; i++) {
c[i] = a[i] * a[i] - b[i] * b[i];
}
return c;
}
40
API plutôt de bas niveau, verbeuse, dépendant partiellement du CPU
Mais qui peut offrir de meilleures performances que le code scalaire équivalent
Exemple Java 21
static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;
static float[] calculerVectoriel(float[] a, float[] b) {
float[] c = new float[a.length];
int i = 0;
for (; i < SPECIES.loopBound(a.length) ; i += SPECIES.length()) {
var va = FloatVector.fromArray(SPECIES, a, i);
var vb = FloatVector.fromArray(SPECIES, b, i);
var vr = va.mul(va).sub(vb.mul(vb));
vr.intoArray(c, i);
}
for (; i < a.length; i++) {
c[i] = a[i] * a[i] - b[i] * b[i];
}
return c;
}
Vector API (Sixth Incubator)

41. Sciam
Les API de Java Core
Sequenced Collections

42. Sciam
Sequenced collections
L’API Collections propose des collections ordonnées
Mais n’est pas homogène dans les fonctionnalités proposées
42
Les opérations liées à l'ordre de parcours sont soit incohérentes soit absentes
Premier élément Dernier élément
List list.get(0) list.get(list.size() - 1)
Deque deque.getFirst() deque.getLast()
SortedSet sortedSet.first() sortedSet.last()
LinkedHashSet linkedHashSet.iterator().next()
Des implémentations permettent d'obtenir le premier ou le dernier élément
Chacune avec leurs méthodes, dont certaines pas évidentes ou inexistantes
Idem pour le parcours dans l’ordre inverse

43. Sciam
Sequenced collections
Introduire 3 nouvelles interfaces
Pour représenter des collections avec un ordre de parcours défini
43
Elles possèdent :
Des éléments parcourables du premier au dernier élément dans un certain ordre
Fournissent des API uniformes pour accéder au 1er et dernier élément
Et pour parcourir ses éléments dans l'ordre inverse
SequencedSet
SequencedCollection
SequencedMap

44. Sciam
Sequenced collections
44

45. Sciam
La JVM HotSpot
Generational ZGC
Generational Shenandoah (Experimental)
Deprecate the Windows 32-bit x86 Port for Removal
Prepare to Disallow the Dynamic Loading of Agents

46. Sciam
Generational ZGC
Rendre le ramasse-miettes ZGC générationnel
46
Tout en maintenant les caractéristiques actuelles
Activation avec les options :
-XX:+UseZGC -XX:+ZGenerational
Les tailles de tas allant de quelques centaines de Mo à plusieurs To
Les temps de pause ne doivent pas dépasser 1 milliseconde
ZGC générationnel devrait être une meilleure solution
Pour la plupart des cas d'utilisation que le ZGC non générationnel

47. Sciam
Generational Shenandoah
(Experimental)
Améliorer le ramasse-miettes Shenandoah
Avec des capacités expérimentales de collecte générationnelle
47
Plusieurs buts :
Réduire l'empreinte mémoire sans sacrifier les temps de pauses
Réduire la consommation CPU
Diminuer le risque d'avoir des full collections lors de pics d'allocations
Maintenir un débit élevé et le support des les pointeurs d'objets compressés
Activation avec les options :
-XX:+UnlockExperimentalVMOptions -XX:ShenandoahGCMode=generational
Configuration avec les options existantes :
-XX:NewRatio=<n>
-XX:NewSize=<size>
-XX:MaxNewSize=<size>

48. Sciam
Conclusion

49. Sciam
Conclusion
Java poursuit son évolution en respectant son modèle de releases
La syntaxe, particulièrement le pattern matching
49
Java 21 proposent des fonctionnalités concernant
Cela permettra à Java de rester pertinent aujourd’hui et demain
Une meilleure utilisation du matériel moderne
La programmation parallèle et concurrente
N’hésitez pas à télécharger l’Early Access : https://jdk.java.net/21/
Java 21, le 19 septembre 2023
Pour anticiper la release de la prochaine version LTS de Java

50. Sciam
L’écosystème Java en 2023
50
• Jakarta EE 10 et Microprofile 6.0
• Spring Boot 3, GraalVM et images natives
• CRaC vs GraalVM
Antoine
Brian
Lilian
Hervé
• Software Supply Chain, SBOM et signature
avec Maven

51. Sciam
Merci pour votre attention

52. Sciam