Cours avancé de programmation concurrente et réactive

Leçon 1 • Conditions de course et atomicité

Identifie les conditions de course à travers les motifs « vérifier puis agir » et « lire-modifier-écrire ». Introduit l'atomicité comme exigence fondamentale de correction.

Leçon 2 • Processus, threads et unités d'exécution

Définit les processus, les threads et les 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 de tas et pourquoi les caches du __TS_PROTECTED_ID_0__ provoquent des lectures obsolètes. Relie les problèmes de visibilité à de véritables bogues 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 formels de correction. Sert de base aux décisions ultérieures de conception verrouillée et sans verrou.

Leçon 1 • Lock Granularity et Contention

Analyse les compromis du verrouillage à grain fin ou grossier à l'aide des métriques de débit et de latence. Introduit le partitionnement des verrous comme technique évolutive de réduction de la contention.

Leçon 2 • Read-Write Locks et Condition Variables

Introduit les verrous en lecture partagée/écriture exclusive pour les charges de travail à forte lecture. Associe les variables de condition aux mutex pour la coordination par attente/notification.

Leçon 3 • Semaphores et Barriers

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'utilisation canonique.

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

Catalogue l'inversion de verrous, l'acquisition de verrous imbriqués et les fuites de verrous comme défauts récurrents. Fournit des motifs de remaniement pour éliminer chaque écueil.

Leçon 1 • L'immutabilité comme stratégie de concurrence

Montre comment les objets immuables éliminent totalement la synchronisation. Couvre l'immuabilité effective, la copie défensive et les structures de données persistantes.

Leçon 2 • Concurrent Queues 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 • Atomic Variables et CAS Operations

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

Leçon 4 • Wrappers de collection thread-safe

Examine les wrappers synchronisés et leurs écueils liés aux opérations composées. Motive l'utilisation de collections concurrentes dédiées plutôt que l'encapsulation naïve.

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 solutions de repli au sein du pipeline.

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

Introduit l'abstraction d'exécuteur qui dissocie la soumission de 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 Promises

Soumet des tâches Callable et récupère les résultats via Future, en gérant l'annulation et le dépassement de délai. Introduit Promise comme le côté écriture d'un future.

Leçon 4 • Fork-Join et Work Stealing

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 • Observable et Observer Contract

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 piloté par poussée central à 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 • Construire une bibliothèque réactive minimale

Implémente un observable, un abonnement et un opérateur map jouets à 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 d'abandon, de mise en mémoire tampon et de limitation pour gérer les producteurs plus rapides. Sélectionne la stratégie appropriée en fonction de la tolance à la perte de données et des objectifs de latence.

Leçon 1 • Combination Operators

Fusionne, zippe et combine plusieurs flux en sorties unifiées. Explique la sémantique temporelle qui détermine quand les émissions combinées se produisent.

Leçon 2 • Transformation Operators

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 • Multicasting et Sharing Streams

Convertit les observables froids en observables 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 • Error Handling et Recovery Operators

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

Leçon 1 • Eliminating Blocking Code

Identifie les appels bloquants qui bloquent les threads réactifs et les encapsule dans deferred ou fromCallable. Applique les planificateurs d'entrées-sorties pour isoler le travail bloquant.

Leçon 2 • subscribeOn et observeOn Operators

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

Leçon 3 • Scheduler Types et Responsibilities

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

Leçon 4 • Reactive Integration with Async I/O

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

Leçon 1 • Performance Profiling et Tuning

Profile la surcharge des opérateurs, les taux d'allocation et la contention des threads à l'aide de profileurs asynchrones. Applique la fusion, le levage d'opérateurs et le réglage des pools pour réduire la latence.

Leçon 2 • Observability et Metrics

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 • Testing Concurrent et Reactive Code

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 • Rate Limiting et Throttling

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