Formation Multithreading en Go

Leçon 1 • Synchronisation des 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 à l'aide d'exemples et de l'outil détecteur 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 • Fonctionnement interne de l'exécution Go et de son ordonnanceur

Examinez le modèle de threading M:N et l'algorithme de vol de travail de l'ordonnanceur Go. Établit le socle d'exécution dont dépend chaque motif de concurrence ultérieur.

Leçon 1 • Parcours de canaux avec 'range' et signaux d'arrêt

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

Leçon 2 • Types de canaux directionnels

Restreignez la direction d'un canal à l'aide d'annotations de type 'send-only' et 'receive-only' 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 canaux simultanément et implémenter des délais d'attente. Débloque les motifs de 'fan-in' et les flux de contrôle concurrents adaptatifs.

Leçon 4 • Canaux tamponnés vs. non tamponnés

Comparez les canaux non tamponnés synchrones avec les canaux tamponnés asynchrones 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 Go

Interprétez les garanties formelles du modèle mémoire de Go pour les opérations de synchronisation. Préviens 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 une exécution unique du code d'initialisation à travers des goroutines concurrentes avec sync.Once. Résout le problème d'initialisation du 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 les types primitifs à l'aide du paquet sync/atomic. Permet des compteurs et des drapeaux haute performance sans la surcharge d'un mutex.

Leçon 1 • Annulation avec WithCancel

Propagez les signaux d'annulation à travers les arbres de goroutines à l'aide de WithCancel et CancelFunc. Permet un arrêt propre des goroutines déclenché par les décisions du parent.

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

Appliquez l'annulation et les délais d'attente de contexte à l'intérieur des gestionnaires de serveur HTTP et gRPC. Démontre des motifs d'intégration concrets qui renforcent tous les concepts de contexte précédents.

Leçon 3 • Délais et timeouts

Limitez la durée des opérations avec WithDeadline et WithTimeout pour éviter un blocage indéfini. Applicable directement 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 à l'aide de WithValue et récupérez-les de manière sécurisée. Couvre le typage correct des clés pour éviter les collisions dans les grandes bases de code.

Leçon 1 • Fan-In : fusion des 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 motif fan-out/fan-in pour la collecte parallèle des travaux.

Leçon 2 • Fan-Out : distribution du travail

Distribuez un seul canal d'entrée à plusieurs goroutines de travail pour paralléliser le traitement. S'appuie sur les fondamentaux du pipeline 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 'token-bucket' et le 'ticker' à l'intérieur des étapes du pipeline pour contrôler le débit. Empêche la surcharge des systèmes en aval dans les systèmes de traitement de données en production.

Leçon 4 • Motif générateur

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

Leçon 1 • Dimensionnement dynamique du pool

Ajustez le nombre de travailleurs en cours d'exécution en fonction de la profondeur de la file d'attente et des métriques de charge du 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 des tâches par priorité à l'aide de 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 travailleurs.

Leçon 3 • Gestion des erreurs dans les pools de travailleurs

Collectez, agrégez et remontez les erreurs provenant de travailleurs concurrents sans perdre les 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 travailleurs à des courtiers de messages externes pour une livraison durable des tâches avec garantie 'au moins une fois'. Fait le pont entre la concurrence intra-processus et les architectures de traitement de tâches distribuées.

Leçon 1 • Détection et prévention des interblocages

Reconnaissez les motifs d'interblocage grâce à l'analyse de l'ordre de verrouillage et au 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 élèves pour résoudre les problèmes subtils de progression invisibles pour le détecteur de courses.

Leçon 3 • Détection des fuites de goroutines

Trouvez et éliminez les goroutines qui ne se terminent jamais à l'aide de métriques d'exécution et de '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 les rapports de courses complexes. Passe au-delà de la détection de base pour une é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 à l'aide de 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 • GOMAXPROCS et réglage de l'ordonnanceur

Réglez GOMAXPROCS et les nombres 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 du 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 à forte concurrence mesurés dans les profils précédents.