Formation Multithreading avec Go

Leçon 1 • Synchronisation de Goroutines avec WaitGroups

Utilisez sync.WaitGroup pour coordonner l'achèvement des goroutines sans attente active. Fournit le premier outil de synchronisation pratique avant l'introduction des canaux.

Leçon 2 • Comprendre les Conditions de Course

Identifiez les courses de données à travers des exemples et l'outil de détection de courses de Go. Pose le contexte du problème qui motive tous les mécanismes de synchronisation enseignés plus tard.

Leçon 3 • Les rouages du Runtime et de l'Ordonnanceur de Go

Examinez le modèle de threading M:N et l'algorithme de vol de travail de l'ordonnanceur de Go. Établit la base du runtime dont dépend chaque modèle de concurrence ultérieur.

Leçon 1 • Itération sur les Canaux et Signaux Done

Itérez sur la sortie d'un canal avec range et signalez la terminaison via des canaux done. Établit des modèles d'arrêt propre réutilisés dans les chapitres sur les pipelines et les pools de workers.

Leçon 2 • Types de Canaux Directionnels

Restreignez la direction d'un canal en utilisant des annotations de type envoi-seulement et réception-seulement pour appliquer des contrats d'API. Améliore la sécurité du code et documente l'intention dans les API concurrentes.

Leçon 3 • Instruction Select et Multiplexage

Utilisez select pour attendre plusieurs opérations sur des canaux simultanément et implémenter des délais d'attente. Débloque les modèles de fan-in et les flux de contrôle concurrents réactifs.

Leçon 4 • Canaux Tamponnés vs. Non Tamponnés

Comparez les canaux synchrones non tamponnés avec les canaux asynchrones tamponnés et leur sémantique de capacité. Permet des décisions correctes de dimensionnement des canaux dans les conceptions de pipelines ultérieures.

Leçon 1 • Essentiels du Modèle Mémoire de Go

Interprétez les garanties formelles du modèle mémoire de Go pour les opérations de synchronisation. Prévient les bogues subtils causés par le réordonnancement du compilateur et du CPU dans le code concurrent.

Leçon 2 • sync.Once et Initialisation Paresseuse

Garantissez l'exécution unique d'un code d'initialisation entre des goroutines concurrentes avec sync.Once. Résout le problème d'initialisation de singleton de manière sécurisée dans les programmes concurrents.

Leçon 3 • sync.Mutex et sync.RWMutex

Verrouillez et déverrouillez des ressources partagées avec Mutex et optimisez les charges de travail à forte lecture avec RWMutex. Fournit l'outil fondamental de protection de l'état partagé pour ce chapitre.

Leçon 4 • Opérations Atomiques avec sync/atomic

Effectuez des lectures et écritures sans verrou sur des types primitifs en utilisant le paquet sync/atomic. Permet des compteurs et drapeaux hautes performances sans la surcharge d'un mutex.

Leçon 1 • Annulation avec WithCancel

Propaguez les signaux d'annulation à travers les arbres de goroutines en utilisant WithCancel et CancelFunc. Permet un arrêt propre des goroutines déclenché par des décisions parentes.

Leçon 2 • Context dans les Gestionnaires HTTP et gRPC

Appliquez l'annulation et les délais d'attente du contexte à l'intérieur des gestionnaires de serveur HTTP et gRPC. Démontre des modèles d'intégration du monde réel qui renforcent tous les concepts de contexte précédents.

Leçon 3 • Délais et Temporisations

Limitez la durée des opérations avec WithDeadline et WithTimeout pour éviter un blocage indéfini. Directement applicable aux appels réseau, aux requêtes de base de données et aux gestionnaires RPC.

Leçon 4 • Stockage et Récupération de Valeurs dans le Contexte

Attachez des valeurs liées à la requête au contexte en utilisant WithValue et récupérez-les en toute sécurité. Couvre le typage correct des clés pour éviter les collisions dans les grandes bases de code.

Leçon 1 • Fan-In : Fusion de Résultats

Fusionnez plusieurs canaux de sortie en un seul en utilisant des goroutines et select pour l'agrégation des résultats. Complète le modèle fan-out/fan-in pour la collecte de travail parallèle.

Leçon 2 • Fan-Out : Distribution du Travail

Distribuez un seul canal d'entrée entre plusieurs goroutines de travail pour paralléliser le traitement. S'appuie sur les fondamentaux des pipelines pour exploiter le matériel multi-cœur.

Leçon 3 • Limitation de Débit dans les Pipelines

Appliquez une limitation de débit basée sur le seau à jetons et le ticker dans les étapes du pipeline pour contrôler le débit. Empêche la surcharge des systèmes aval dans les systèmes de production de traitement de données.

Leçon 4 • Modèle Générateur

Produisez des flux de valeurs à partir de goroutines en utilisant l'idiome du générateur pour l'évaluation paresseuse. Permet une source de données économe en mémoire pour les étapes du pipeline.

Leçon 1 • Dimensionnement Dynamique du Pool

Ajustez le nombre de workers à l'exécution en fonction de la profondeur de la file d'attente et des métriques de charge système. Étend le pool statique pour gérer des charges de travail variables sans sur-provisionnement.

Leçon 2 • Files d'Attente de Tâches Prioritaires

Implémentez un ordonnancement de tâches par priorité en utilisant des files basées sur un tas avec protection par mutex. Permet des niveaux de service différenciés au sein d'un seul pool de workers.

Leçon 3 • Gestion des Erreurs dans les Pools de Workers

Collectez, agrégez et remontez les erreurs des workers concurrents sans perdre de résultats. Assure la fiabilité et l'observabilité du pool requises dans les environnements de production.

Leçon 4 • Files d'Attente de Tâches Persistantes et Durables

Connectez les pools de workers à des courtiers de messages externes pour une livraison durable de tâches au moins une fois. Fait le pont entre la concurrence en processus et les architectures de traitement de tâches distribuées.

Leçon 1 • Détection et Prévention des Interblocages

Reconnaissez les modèles d'interblocage à travers l'analyse de l'ordre de verrouillage et le détecteur d'interblocage intégré de Go. Fournit des stratégies de prévention applicables à toute utilisation de mutex et de canaux.

Leçon 2 • Livelock et Famine

Distinguez le livelock de l'interblocage et identifiez la famine dans l'ordonnancement des goroutines. Équipe les étudiants pour résoudre des problèmes subtils de progression invisibles pour le détecteur de courses.

Leçon 3 • Détection de Fuites de Goroutines

Trouvez et éliminez les goroutines qui ne se terminent jamais en utilisant les métriques du runtime et goleak. Empêche l'épuisement de la mémoire et du CPU dans les services à longue durée de vie.

Leçon 4 • Utilisation Avancée du Détecteur de Courses

Intégrez le détecteur de courses dans les pipelines CI et interprétez des rapports de courses complexes. Passe au-delà de la détection de base vers l'élimination systématique des courses dans les grandes bases de code.

Leçon 1 • Structures de Données Sans Verrou

Construisez des piles et des files sans verrou en utilisant des primitives atomiques compare-and-swap. Fournit des alternatives à haut débit aux structures protégées par mutex pour des charges de travail spécifiques.

Leçon 2 • Réglage de GOMAXPROCS et de l'Ordonnanceur

Réglez GOMAXPROCS et les comptes de goroutines pour correspondre à la topologie matérielle et au type de charge de travail. Traduit les connaissances sur l'ordonnanceur du Chapitre 1 en gains de performance mesurables.

Leçon 3 • Benchmarking de Code Concurrent

Écrivez des benchmarks concurrents fiables en utilisant testing.B et évitez les pièges de mesure courants. Assure que les affirmations de performance sont reproductibles et statistiquement significatives.

Leçon 4 • Réduction de la Contention sur les Verrous

Appliquez le partitionnement, la mise en cache locale et le verrouillage à grain fin pour minimiser la contention sur les mutex. Améliore directement le débit dans les services à haute concurrence mesurés dans le profilage précédent.