Programmation concurrente

JobRunr supporte les threads virtuels de Java

Soumis par fredericmazue le

JobRunr est un framework qui simplifie la programmation concurrente en Java. Avec JobRunr il est aisé de réaliser des tâches de type "fire-and-forget", retardées, planifiées et récurrentes dans des applications Java en utilisant uniquement les lambdas de Java 8.

Les tâches gourmandes en CPU et en E/S, de longue durée et de courte durée, sont prises en charge. Le stockage persistant s'effectue soit via un SGBDR (par exemple Postgres, MariaDB/MySQL, Oracle, SQL Server, DB2 et SQLite) ou NoSQL (ElasticSearch, MongoDB et Redis).

JobRunr fournit un modèle de programmation unifié pour gérer les tâches en arrière-plan et les exécute sur un hébergement partagé, un hébergement dédié ou dans le cloud (Kubernetes  par exemple) au sein d'une instance JVM. JobRunr vient de sortir en version 7.0.

L'apport majeur de cette version 7.0 est la prise en charge des threads virtuels, activés par défaut, pour les applications exécutant JDK 21. L'outil détecte si l'application s'exécute sur JDK 21 et passe automatiquement aux threads virtuels sans nécessiter de configuration manuelle de la part des développeurs.

Il est à noter que JobRunr 7.0 maintient également une compatibilité descendante avec Java 8. JobRunr 7.1, en préversion au moment où nous écrivons ces lignes, prend également en charge les threads virtuels en mode natif GraalVM.

JobRunr est un logiciel libre sous plusieurs licences, disponible sur GitHub.

Des exemples de programmation concurrente en Swift

Soumis par fredericmazue le

La programmation concurrente en Swift peut être difficile à maîtriser. Disposer de bons exemples peut s'avérer être une grande aide. C'est avec cette intention que Matt Massicotte, développeur Swift, et ancien employé de Crashlytics et Apple à créé un dépôt GitHub pout partager des solutions et mettre en évidence les dangers.

Matt Massicotte ne prétend pas être exhaustif ni que ses solutions sont les meilleures. Au contraire, il invite aux contributions pour continuer d'apprendre. Son dépôt n'en est que plus intéressant.

Les aspects abordés en programmation Swifit concurrente sont pour le moment les suivants :

  • Création d'un contexte asynchrone
  • Utiliser des protocoles
  • Isolement
  • Concurrence structurée
  • SwiftUI
  • Utilisation de bibliothèques non conçues pour la concurrence
  • Interopérabilité

Les dangers rencontrés en programmation Swift concurrente références par ce dépôt sont pour le moment les suivants :

  • Timing : plusieurs options sont disponibles, mais peuvent affecter le moment où les événements se produisent réellement.
  • Commande : les tâches non structurées signifient que la commande dépend de l'appelant. Réfléchissez bien aux dépendances, aux appels multiples et à l’annulation.
  • Absence de contrôle de l'appelant : les définitions contrôlent toujours le contexte de l'acteur. Ceci est différent des autres modèles de thread et vous ne pouvez pas modifier les définitions que vous ne contrôlez pas.
  • Envoyabilité : les types qui traversent les domaines d'isolation doivent être expédiables. Ce n'est pas toujours facile, et pour les types que vous ne contrôlez pas, ce n'est pas possible.
  • Blocage : la concurrence Swift utilise un pool de threads de taille fixe. L'interconnexion des threads d'arrière-plan peut entraîner un décalage, voire une impasse.
  • Disponibilité : la concurrence évolue rapidement et certaines API nécessitent le dernier SDK.
  • Viralité asynchrone : Rendre une fonction asynchrone affecte tous ses sites d'appel. Cela peut entraîner un grand nombre de changements, dont chacun pourrait lui-même affecter les sites d’appel de la sous-séquence.
  • Réentrée d'acteur : plusieurs threads peuvent entrer dans les méthodes asynchrones d'un acteur. L'état d'un acteur peut changer au fil des attentes.

Ces exemples de programmation concurrente en Swift sont des logiciels libres sous licence BSD 3-Clause "New", disponibles sur GitHub.

 

Java 21 : une concurrence améliorée grâce aux valeurs délimitées

Soumis par fredericmazue le

Les valeurs délimitées, ou Scoped values, ont été intégrées à Java 21 qui sortira en version finale au mois de septembre de cette année. Les valeurs délimitées provient du projet Loom, tout comme les threads virtuels et la concurrence structurée. Java 21 intègre les valeurs délimitées en prévisualisation seulement.

Les valeurs délimitées permettent le partage de données immuables au sein et entre les threads. Elles sont préférables aux variables locales de thread, en particulier lors de l'utilisation d'un grand nombre de threads virtuels.

Une valeur délimitée se comporte comme un paramètre supplémentaire de méthode dans la séquence d'appels, mais la méthode ne déclare pas ce paramètre. Seules les méthodes qui ont accès à l'objet ScopedValue peuvent récupérer sa valeur, qui encapsule les données transmises.

Les valeurs délimitées sont décrites techniquement en détail dans JEP 446

Java : les threads virtuels arrivent avec JDK 21

Soumis par fredericmazue le

La proposition JEP 444 a été promue du statut de 'Candidate' à celui de 'Proposed to Target' pour JDK 21. JEP 444 définit les threads virtuels à la suite de JEP 425 et JEP 436 qui avaient abouti à une avant-première de ceux-ci dans JDK 19 et JDK 20 respectivement. Les threads virtuels seront donc une fonctionnalité utilisable en production avec JDK 21.

Les threads virtuels viennent repousser une limitation induite par les threads classiques de Java. En effet ceux-ci s'appuient sur sur le système d'exploitation sous jacent, ce qui limite leur nombre à quelques milliers d'instance simultanées. Les threads virtuels, qui rappellent les processus du langage Erlang dédié à la programmation concurrente, sont totalement internes à la JVM, et de ce fait il est possible d'en instancier des millions.

JEP 444 apportent des évolutions aux threads virtuels des versions précédentes. Ainsi les threads virtuels prennent désormais en charge les variables locales de thread tout le temps. Il n'est plus possible, comme c'était le cas dans les versions préliminaires, de créer des threads virtuels qui ne peuvent pas avoir de variables locales de thread. La prise en charge garantie des variables locales de thread assure que de nombreuses autres bibliothèques existantes peuvent être utilisées sans modification avec les threads virtuels et facilite la migration du code orienté tâche pour utiliser les threads virtuels.

Cette arrivée des threads virtuels induit de nombreux changements dans les API Java. Par exemple, le package java.util.concurrent inclut désormais la prise en charge des threads virtuels. L'API LockSupport a été mise à jour pour parquer et déparquer les threads virtuels et permettre ainsi aux API qui utilisent LockSupport, telles que les verrous , les sémaphores et les files d'attente de blocage, de fonctionner de manière transparente avec les threads virtuels. Le package java.io a été mis à jour également.

La JNI (Java Native Interface) est dotée d'une nouvelle fonction, IsVirtualThread, pour tester si un objet est un thread virtuel. JDK Flight Recorder (JFR) prend désormais en charge les threads virtuels avec de nouveaux événements tels que jdk.VirtualThreadStart, jdk.VirtualThreadEnd, jdk.VirtualThreadPinned et jdk.VirtualThreadSubmitFailed.

Par contre Java Management Extensions ( JMX ) ne continue à prendre en charge que les threads de plate-forme, ou threads classiques.

La concurrence structurée pour Java 19 ?

Soumis par fredericmazue le

Nous savons que les threads virtuels arriveront en préversion dans JDK 19. Une proposition, JEP 428, vient d'être mise à jour. Cette proposition est baptisée Structured Concurrency, ou concurrence structurée. Elle nous semble très complémentaire aux threads virtuels du futur Java 19.

La concurrence structurée est une approche de la programmation multithread qui préserve la lisibilité et la maintenabilité dont bénéficient les développeurs de code monothread. Le principe de base est que si une tâche se divise en sous-tâches concurrentes, elles retournent toutes au même endroit : le bloc de code de la tâche.

En "revenant" au même bloc de code, la durée de vie d'une sous-tâche concurrente est confinée à un bloc syntaxique. Étant donné que la durée de vie de toutes les sous-tâches sœurs est confinée au même bloc, elles peuvent être raisonnées et gérées comme une unité.

JEP 428 souligne que la concurrence structurée convient parfaitement aux threads virtuels. Les threads virtuels sont une implémentation légère des threads fournis par le JDK, et abstraits du système d'exploitation. En tant que tels ils pourront être instanciés par millions.

En résumé, si les threads virtuels fournissent une abondance de threads, c'est la concurrence structurée qui garantira que ceux-ci sont correctement et solidement coordonnés.

Mark Reinhold, Chief Architect of the Java Platform Group chez Oracle vient de proposer de cibler JEP 428 sur Java 19. Si aucune objection n'est faite, nous devrions avoir une première préversion de la concurrence structurée avec la sortie de JDK 19 prévue en septembre.

Les threads virtuels arriveront en préversion dans JDK 19

Soumis par fredericmazue le

Mark Reinhold, Chief Architect of the Java Platform Group chez Oracle, vient de cibler la proposition JEP 425 sur JDK 19.

Cette JEP 425 introduit les threads virtuels du projet Loom dans Java. 

Alors que les threads Java classiques s'appuient sur le système d'exploitation sous jacent, ce qui limite leur nombre à milliers d'instance simultanées, JEP 425 introduit la notion de thread virtuel, appelé fibre, et abstrait du système d'exploitation. Avec ces threads virtuels, il deviendra possible d'instancier des millions de threads en Java. Un thread virtuel peut être lancé ainsi :

Thread.startVirtualThread(
  () -> {
    System.out.println("Hello World");
  }
);

JEP 425 précise que les threads virtuels sont des threads légers qui réduisent considérablement l'effort d'écriture, de maintenance et d'observation des applications simultanées à haut débit.

Les threads virtuels arriveront donc en préversion dans Java 19, dont la sortie est prévue en septembre 2022.

Projet Loom : des threads virtuels pour la JVM

Soumis par fredericmazue le

Parmi les nouveautés Java attendues pour 2022 figure le projet Loom. Loom veut révolutionner la programmation concurrente en Java en offrant offre une alternative plus légère aux threads ainsi que de nouvelles constructions de langage pour les gérer.

Les threads Java classiques s'appuient sur le système d'exploitation sous jacent, ce qui limite leur nombre à quelques milliers d'instance simultanées. Loom introduit la notion de thread virtuel, appelé fibre, et abstrait du système d'exploitation. Un thread virtuel peut être lancé ainsi :

Thread.startVirtualThread(
  () -> {
    System.out.println("Hello World");
  }
);

Ceci n'est pas sans rappeler le langage Erlang, dédié à la programmation concurrente, et conçu par Ericson pour piloter des systèmes concurrents très chargés, notamment des systèmes de télécommunications. Avec ces threads virtuels à la Erlang, il deviendra possible d'instancier des millions de threads en Java.

Avec les threads virtuels, le projet apporte la continuation. Une continuation est une représentation abstraite de l'état de contrôle d'un programme informatique. Loom implémente des continuations à la fois pour étayer les fibres et pour exposer les fibres en tant qu'API publique que les développeurs peuvent utiliser dans les applications. En d'autres termes, une continuation permet au développeur de manipuler le flux d'exécution en appelant des fonctions.

Le développement de Loom est très actif. Il peut être suivi à partie de cette page d'Oracle. Il peut déjà être testé sur des JVM expérimentales. 

Les aspects techniques du projet Loom sont exposés dans cette proposition.

Swift 5.5 améliore la programmation concurrente

Soumis par fredericmazue le

Apple a publié la version 5.5 de son langage de programmation Swift. Il s'agit d'une version majeure, qu'Apple qualifie même de 'massive'. Cette version apporte par exemple une meilleure interopérabilité avec Objective-C, les collections de paquets... Mais ce qui distingue surtout Swift 5.5 sont ses apports en ce qui concerne la programmation concurrente, au centre de laquelle se trouvent désormais les mots-clés async et await, qui ne sont pas sans rappeler ceux de C#.

Avec les versions précédentes du langage, une séquence d'opérations asynchrones simples nécessitait souvent des fermetures profondément imbriquées. Voici un exemple de code donné par Apple pour illustrer cela :

func processImageData1(completionBlock: (_ result: Image) -> Void) {
    loadWebResource("dataprofile.txt") { dataResource in
        loadWebResource("imagedata.dat") { imageResource in
            decodeImage(dataResource, imageResource) { imageTmp in
                dewarpAndCleanupImage(imageTmp) { imageResult in
                    completionBlock(imageResult)
                }
            }
        }
    }
}

processImageData1 { image in
    display(image)
}

Apple décrit un tel code comme une 'pyramide condamnée' (pyramid of doom). Cette pyramide condamnée rend difficile la lecture et le suivi de l'exécution du code. De plus, devoir utiliser une pile de fermetures entraîne de nombreux effets de second ordre qui sont décrit dans la proposition SE-0296 justifiant l'arrivée de async / await.

Les fonctions asynchrones, appelées async / wait, permettent d'écrire du code asynchrone comme s'il s'agissait d'un code synchrone linéaire. Cela résout immédiatement bon nombre des problèmes évoqués ci-dessus en permettant aux programmeurs d'utiliser pleinement les mêmes constructions de langage que celles disponibles pour le code synchrone. L'utilisation d'async/wait préserve également naturellement la structure sémantique du code, fournissant les informations nécessaires à au moins trois améliorations transversales du langage : (1) meilleures performances pour le code asynchrone ; (2) de meilleurs outils pour fournir une expérience plus cohérente lors du débogage, du profilage et de l'exploration du code ; et (3) une base pour les futures fonctionnalités de simultanéité telles que la priorité et l'annulation des tâches. 

Le mot-clé async déclare une fonction comme asynchrone, et l’appel est effectué via le mot-clé await. Voici un exemple de code tiré de SE-0296 donné par Apple :

func loadWebResource(_ path: String) async throws -> Resource
func decodeImage(_ r1: Resource, _ r2: Resource) async throws -> Image
func dewarpAndCleanupImage(_ i : Image) async throws -> Image

func processImageData() async throws -> Image {
  let dataResource  = try await loadWebResource("dataprofile.txt")
  let imageResource = try await loadWebResource("imagedata.dat")
  let imageTmp      = try await decodeImage(dataResource, imageResource)
  let imageResult   = try await dewarpAndCleanupImage(imageTmp)
  return imageResult
}

Les apports de Swift, vraiment conséquents, ne s'arrêtent pas à cela en ce qui concerne la programmation concurrente. Arrivent également AsyncSequence, la concurrence structurée, AsyncStream et AsyncThrowingStream, de nouveaux types qui remplissent un rôle similaire aux continuations, comblant le fossé entre le comportement asynchrone non basé sur async / await et le monde de async / await, les déclarations async let, qui différent de let en ce que l'expression d'initialisation est évaluée dans une tâche enfant distincte, exécutée simultanément, etc.

La note de version de Swift 5.5 est ici.

Celery 5.0 : la programmation concurrente et distribuée avec Python

Soumis par fredericmazue le

Le framework Celery vient de sortir en version 5.0. Ce framework écrit en Python est dédié à la programmation concurrente et distribuée en Python.

Celery consiste en une file d'attente de tâches asynchrones. La communication entre tâches est faite au moyen de messages distribués. Si Celery prend en charge la planification, il se concentre principalement sur les opérations en temps réels. Les unités d'exécution, ou tâches, sont exécutées simultanément sur un ou plusieurs noeuds. Ces tâches peuvent être totalement asynchrones ou bien s'attendre les unes les autres grâce au mécanisme de passage de messages. Instagram, notamment, utilise Celery pour traiter des millions de tâches chaque jour.

Cette mouture de Celery est une version majeure, qui ne supporte  plus que Python 3.6, 3.7, 3.8. Ce qui peut obliger les utilisateurs de Celery qui jusqu'ici ont travaillé avec Python 2.7 ou 3.5 à mettre à jour leur code pour le rendre compatible avec Python 3.6. Les utilisateurs qui ne veulent pas abandonner python 2.7 ou Python 3.5 doivent continuer à utiliser Celery 4.x, soulignent les responsables du projet. En tant que versions LTS, Celery 4.x sera supportée jusqu'au 1er août 2021.

A remarquer encore, une nouvelle interface en ligne de commande a été introduite avec Celery 5.0, qui n'est pas entièrement compatible avec les versions précédentes.

Celery 5.0 n'est pas une version LTS, et ne sera supporté que jusqu'à la sortie de Celery 6.0.

Celery est un logiciel libre sous licence Celery (dérivée de la licence BSD), disponible sur GitHub.

Celery dispose d'un site officiel sur lequel on trouvera un guide de démarrage et une documentation complète.

Soirée Programmation concurrente au <%LorraineJUG%>

Soumis par fredericmazue le

Le Lorraine JUG (Java User Group de Lorraine) vous invite à sa prochaine soirée de conférence sur le thème de la programmation concurrente.

Au programme de la soirée :

18:15 - Accueil et enregistrement

18:30 - Programmation concurrente : enjeux et problèmes, moyens et solutions José Paumard

Depuis 15 ans le modèle de programmation multithread de Java a suivi les évolutions des processeurs et les besoins grandissants des applications. La programmation multithread pose deux défis pour le développeur : paralléliser ses traitements et assurer la cohérence de ses données, tout en exploitant au maximum la puissance de calcul des processeurs modernes. Nous commencerons par décrire ces défis précisément, ainsi que leurs enjeux. Nous verrons ensuite les solutions techniques disponibles actuellement, que ce soit dans le JDK ou dans les API et frameworks de l'écosystème Java. De l'API Java Threads des débuts, au Fork / Join de Java 7, et au parallel() en vue pour Java 8, de synchronized et volatile aux modèles de transactions logicielles et d'acteurs, tout y passera, précisément et sans complaisance. Et en bonus, on fera un peu d'algorithmique.

José est maître de conférences à l'institut Galilée (université Paris 13) et docteur en mathématiques appliquées de l'ENS de Cachan. Il découvre Java en 1995, et enseigne le langage et ses API depuis 2000 en DESS (devenu M2 depuis). Il y a 10 ans, José rencontre Pierre Briant et se passionne depuis pour les bases de données historiques et archéologiques. Il codirige dans ce cadre le projet MAVI en collaboration avec le collège de France, et publie en open source Open melodie plateforme Java qui joue le rôle de back-office du MAVI. Il tient le blog Java le soir, qui propose environ 700 pages de cours et tutoriaux Java / JEE en accès libre. Enfin, José apporte régulièrement son concours à de nombreux projets techniques dans des domaines très divers.

20:45 - Drink et tombola

1 licence JRebel à gagner, offerte par ZeroTurnaround.

Lundi 21 mai 2012, 18h30. Ecole Supérieure d'Informatique et Applications de Lorraine

193 av. Paul Muller, 54602 Villers-lès-Nancy

Inscription gratuite