Cours avancé de programmation concurrente et réactive

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

Identifie les situations de compétition par les motifs vérification-puis-action et lecture-modification-écriture. Présente l'atomicité comme l'exigence fondamentale d'exactitude.

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

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

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

Explique comment les fils d'exécution partagent la mémoire de tas et pourquoi les caches du CPU provoquent des lectures périmées. Relie les problèmes de visibilité à de véritables bogues de corruption de données.

Leçon 4 • Critères d'exactitude de la concurrence

Définit la linéarisabilité, la cohérence séquentielle et la sérialisabilité comme des modèles d'exactitude formels. Établit les bases des décisions de conception avec et sans verrouillage.

Leçon 1 • Granularité du verrouillage et contention

Analyse les compromis entre le verrouillage grossier et le verrouillage fin à l'aide de mesures de débit et de latence. Présente le partitionnement de verrouillage comme une technique évolutive de réduction de la contention.

Leçon 2 • Verrous en lecture-écriture et variables de condition

Présente 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 • Sémaphores et barrières

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

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

Inventorie l'inversion de verrouillage, l'acquisition de verrous imbriqués et les fuites de verrous comme 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 d'attente et files double

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

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

Explique la comparaison-échange comme la primitive matérielle sous-jacente aux algorithmes sans verrouillage. Construit des compteurs, des références et des références estampillées atomiques.

Leçon 4 • Enveloppes de collections thread-safe

Examine les enveloppes synchronisées et leurs pièges d'opérations composées. Motive les collections concurrentes conçues à cet effet plutôt que l'encapsulation naïve.

Leçon 1 • Pipelines asynchrones composables

Enchaîne des calculs asynchrones dépendants à l'aide de futurs achevables et de rappels de continuation. Gère les erreurs et les replis dans le pipeline.

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

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

Leçon 3 • Futurs, tâches avec retour et promesses

Soumet des tâches avec retour et récupère les résultats via Future, en gérant l'annulation et le délai d'attente. Présente Promise comme le côté écriture d'un futur.

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

Implémente le parallélisme diviser-pour-régner à l'aide du cadriciel 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 rappels d'observateur. Établit le modèle de flux de données basé sur l'envoi 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 • 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 d'abandon, de mise en tampon et d'étranglement 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, compresse et combine plusieurs flux en sorties unifiées. Explique la sémantique de synchronisation 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 • Multidiffusion et partage de flux

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 • Opérateurs de gestion des erreurs et de récupération

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

Leçon 1 • Élimination du code bloquant

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

Leçon 2 • Opérateurs subscribeOn et observeOn

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

Leçon 3 • Types d'ordonnanceurs et responsabilités

Inventorie les ordonnanceurs de calcul, d'E/S, monofil et trampoline selon leur charge de travail prévue. Associe chaque ordonnanceur à 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 rappels et les futurs vers les flux réactifs. Couvre les pilotes asynchrones TCP, HTTP et de bases de données comme cibles d'intégration.

Leçon 1 • Profilage et optimisation du rendement

Profile la surcharge des opérateurs, les taux d'allocation et la contention des fils d'exécution à l'aide de profileurs asynchrones. Applique la fusion, l'élévation d'opérateur et l'optimisation du pool 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 d'attente. Relie les métriques aux seuils d'alerte pour la surveillance de la production.

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

Utilise des ordonnanceurs à temps virtuel, des abonnés de test et des outils de concurrence déterministes 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 étranglement

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.