Le 21 mars dernier est sorti Java 20, encore une petite version (rien de release, que de l'incubation ou pré-version) mais qui continue de préparer les bases pour l'avenir de Java !

Amélioration des traitements parallèles

Déjà en pré-version depuis Java 19, les thread virtuel continue leur chemin. Pas de vrai changement ici, je pense qu'il manque des éléments autours pour compléter la fonctionnalité.

Et justement les scoped values entrent en incubation. Le but est de proposer un moyen de partager des données immutables entre plusieurs threads. Le principal intérêt étant d'alléger les threads virtuels pour augmenter encore leur vélocité et leur souplesse. Il n'y a aucune obligation à utiliser cette mécanique avec les thread virtuels mais ce sera encouragé car ça améliore la lisibilité en rendant explicite l'existence de données partagées (donc on peut aussi imaginer qu'on pourra avoir des règles Sonar (par exemple) qui nous aide à éviter certaines erreurs spécifiques) tout en proposant un gain en performance.

Exemple de code tiré de la JEPS :

class Server {
    final static ScopedValue<Principal> PRINCIPAL =  ScopedValue.newInstance();

    void serve(Request request, Response response) {
        var level     = (request.isAdmin() ? ADMIN : GUEST);
        var principal = new Principal(level);
        ScopedValue.where(PRINCIPAL, principal)
                   .run(() -> Application.handle(request, response));
    }
}

class DBAccess {
    DBConnection open() {
        var principal = Server.PRINCIPAL.get();
        if (!principal.canOpen()) throw new  InvalidPrincipalException();
        return newConnection(...);
    }
}

Il faut imaginer que la méthode DBAccess.open() est appelé dans Application.handle(). On voit qu'un peu à la manière d'un injecteur on va pouvoir récupérer l'instance courante de PRINCIPAL pour l'utiliser.

Dernier changement en incubation concernant la concurrence structurée (Structured Concurrency) qui est mise à jour pour supporter les scoped values.

Divers améliorations

Les travaux concernant le Switch Pattern Matching continue avec la 4ᵉ pré-version du switch et la seconde pré-version pour Record Patterns. Pas de vrai changement mais un peu plus d'inférence de type ce qui devrait alléger un peu la syntaxe.

Côté Foreign Function and Memory (qui pour rappel vise à offrir une nouvelle manière d'appeler du code venant de l'extérieur de la JVM) rien de vraiment nouveau. On retrouve seulement des petites améliorations plutôt interne et bas niveau mais qui devrait faciliter la suite des travaux.

Et pour finir, une petite mise à jour de la Vector API (toujours en incubation pour la 5ᵉ itération) avec uniquement des bugs fix.

Conclusion

Encore une toute petite version Java pour ce qui est du code qu'on pourra envoyer en production. Mais on peut espérer un peu plus de JPES finie pour la version 21. À l'heure où j'écris, les virtual threads sont déjà validés et seront donc disponible sans restriction. Croisons les doigts pour le Pattern Matching !

Sources :