Cours de programmation concurrente et réactive avancée

Leçon 1 • Conditions de compétition et atomicité

Identifie les conditions de compétition à travers les motifs vérifier-puis-agir et lire-modifier-écrire. Présente l'atomicité comme l'exigence fondamentale de correction.

Leçon 2 • Processus, Threads et Unités d'exécution

Définit les processus, threads et fibres légères comme des unités d'exécution distinctes. Établit le vocabulaire utilisé tout au long du cours.

Leçon 3 • État partagé et visibilité mémoire

Explique comment les threads partagent la mémoire tas et pourquoi les caches CPU provoquent des lectures obsolètes. Relie les problèmes de visibilité à des bogues réels de corruption de données.

Leçon 4 • Critères de correction de la concurrence

Définit la linéarisabilité, la cohérence séquentielle et la sérialisabilité comme des modèles de correction formels. Sert de base aux décisions ultérieures de conception avec et sans verrous.

Leçon 1 • Granularité du verrou et contention

Analyse les compromis entre verrouillage grossier et fin à l'aide de mesures de débit et de latence. Présente le verrouillage par bandes (lock striping) comme une technique de réduction scalable de la contention.

Leçon 2 • Verrous lecture-écriture et variables conditionnelles

Présente les verrous à lecture partagée/écriture exclusive pour les charges de travail à forte lecture. Associe les variables conditionnelles aux mutex pour la coordination attente-notification.

Leçon 3 • Sémaphores et barrières

Utilise les sémaphores compteurs pour limiter les pools de ressources et les barrières cycliques pour synchroniser les phases. Associe chaque primitive à son cas d'usage canonique.

Leçon 4 • Éviter les pièges courants du verrouillage

Catalogue les inversions de verrou, l'acquisition imbriquée de verrous et les fuites de verrous comme des défauts récurrents. Fournit des motifs de refactorisation pour éliminer chaque piège.

Leçon 1 • Immuabilité comme stratégie de concurrence

Démontre comment les objets immuables éliminent complètement la synchronisation. Couvre l'immuabilité effective, la copie défensive et les structures de données persistantes.

Leçon 2 • Files concurrentes et deques

Couvre les implémentations de files bloquantes et non bloquantes pour les pipelines producteur-consommateur. Compare le comportement de contre-pression des files bornées et non bornées.

Leçon 3 • Variables atomiques et opérations CAS

Explique le compare-and-swap comme primitive matérielle sous-jacente aux algorithmes sans verrou. Construit des compteurs, références et références estampillées atomiques.

Leçon 4 • Wrappers de collections thread-safe

Examine les wrappers synchronisés et leurs pièges d'opérations composées. Motive l'utilisation de collections concurrentes dédiées plutôt qu'un wrapping naïf.

Leçon 1 • Pipelines asynchrones composables

Enchaîne des calculs asynchrones dépendants à l'aide de futures complétables et de callbacks de continuation. Gère les erreurs et les replis dans le pipeline.

Leçon 2 • Architecture du framework d'exécution

Présente l'abstraction d'exécuteur qui découple la soumission des tâches de la politique d'exécution. Associe les types d'exécuteurs aux caractéristiques des charges de travail.

Leçon 3 • Futures, Callables et Promesses

Soumet des tâches Callable et récupère les résultats via Future, avec gestion de l'annulation et du délai d'attente. Présente la Promise comme le côté écriture d'un future.

Leçon 4 • Fork-Join et vol de travail

Implémente le parallélisme diviser-pour-régner à l'aide du framework fork-join. Explique l'ordonnancement par vol de travail et ses avantages en termes de débit.

Leçon 1 • Contrat Observable et Observateur

Définit la séquence observable, le cycle de vie de l'abonnement et les callbacks de l'observateur. Établit le modèle de flux de données par poussée au cœur de la programmation réactive.

Leçon 2 • Spécification des flux réactifs

Couvre les quatre interfaces des flux réactifs : Publisher, Subscriber, Subscription et Processor. Explique la signalisation de la demande comme fondement de la contre-pression.

Leçon 3 • Construction d'une bibliothèque réactive minimale

Implémente un observable jouet, un abonnement et un opérateur map à partir de zéro. Consolide la compréhension du contrat avant d'utiliser des bibliothèques de production.

Leçon 4 • Stratégies de contre-pression

Compare les stratégies de suppression, de mise en tampon et de limitation pour gérer les producteurs plus rapides. Sélectionne la stratégie appropriée en fonction de la tolérance à la perte de données et des objectifs de latence.

Leçon 1 • Opérateurs de combinaison

Fusionne, zippe et combine plusieurs flux en sorties unifiées. Explique la sémantique temporelle qui détermine le moment des émissions combinées.

Leçon 2 • Opérateurs de transformation

Couvre map, flatMap, concatMap et switchMap pour la transformation de valeurs et de flux. Distingue les garanties d'ordre et de concurrence de chaque opérateur.

Leçon 3 • Multicast et partage de flux

Convertit les observables froids en chauds à l'aide des opérateurs publish, share et replay. Contrôle le moment de l'abonnement et la taille du tampon de rejeu.

Leçon 4 • Opérateurs de gestion et de récupération d'erreurs

Implémente retry, retryWhen, onErrorReturn et onErrorResume pour des pipelines résilients. Distingue les erreurs récupérables des erreures terminales dans le contexte du flux.

Leçon 1 • Élimination du code bloquant

Identifie les appels bloquants qui bloquent les threads réactifs et les encapsule dans deferred ou fromCallable. Applique des planificateurs d'E/S pour isoler le travail bloquant.

Leçon 2 • Opérateurs subscribeOn et observeOn

Explique comment subscribeOn définit le thread d'abonnement et observeOn change le thread d'observation. Démontre le placement correct pour le threading en amont et en aval.

Leçon 3 • Types de planificateurs et responsabilités

Catalogue les planificateurs de calcul, d'E/S, mono-thread et trampoline par leur charge de travail prévue. Associe chaque planificateur à l'étape de pipeline correcte.

Leçon 4 • Intégration réactive avec les E/S asynchrones

Fait le pont entre les API asynchrones basées sur les callbacks et les futures vers les flux réactifs. Couvre les pilotes asynchrones TCP, HTTP et de base de données comme cibles d'intégration.

Leçon 1 • Profilage de performance et optimisation

Profile le surcoût des opérateurs, les taux d'allocation et la contention des threads à l'aide de profileurs asynchrones. Applique la fusion, la remontée d'opérateur (operator lifting) et l'optimisation des pools pour réduire la latence.

Leçon 2 • Observabilité et métriques

Instrumente les pipelines réactifs avec des histogrammes de latence, des taux d'erreur et des métriques de profondeur de file. Relie les métriques aux seuils d'alerte pour la surveillance en production.

Leçon 3 • Test du code concurrent et réactif

Utilise des planificateurs à temps virtuel, des abonnés de test et des outils de concurrence déterministe pour écrire des tests fiables. Couvre les tests basés sur les propriétés pour les invariants concurrents.

Leçon 4 • Limitation de débit et régulation

Applique les algorithmes de seau à jetons et de seau qui fuit pour plafonner les taux d'émission. Empêche la surcharge en aval tout en maintenant une latence acceptable.