Cours de multithreading avancé en Go

Leçon 1 • Synchronisation des goroutines avec WaitGroups

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

Leçon 2 • Compréhension des situations de compétition

Identifiez les situations de compétition à l'aide d'exemples et de l'outil de détection de situations de compétition de Go.

Leçon 3 • Fonctionnement interne du runtime et de l'ordonnanceur de Go

Examinez le modèle de fils d'exécution M:N et l'algorithme de vol de travail de l'ordonnanceur de Go. Établit les bases du runtime dont dépend chaque modèle de concurrence ultérieur.

Leçon 1 • Parcours de canaux et signaux de fin

Itérez sur la sortie d'un canal avec range et signalez la fin via des canaux done. Établit des modèles d'arrêt propres 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 envoi seulement et réception seulement pour imposer 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éverrouille les modèles de fusion et les flux de contrôle concurrents réactifs.

Leçon 4 • Canaux tamponnés et 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 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 à travers des goroutines concurrentes avec sync.Once. Résout en toute sécurité le problème d'initialisation singleton 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 à prédominance de lectures avec RWMutex. Fournit l'outil fondamental de protection de l'état partagé pour le chapitre.

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

Effectuez des lectures et écritures sans verrou sur des types primitifs à l'aide du paquetage sync/atomic. Permet des compteurs et indicateurs haute performance sans la surcharge d'un mutex.

Leçon 1 • Annulation avec WithCancel

Propaguez 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 • Contexte dans les gestionnaires HTTP et gRPC

Appliquez l'annulation et les délais de contexte à l'intérieur des gestionnaires de serveur HTTP et gRPC. Démontre des modèles d'intégration concrets 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 bases de données et aux gestionnaires RPC.

Leçon 4 • Stockage et récupération de valeurs dans le contexte

Attachez des valeurs propres à une requête au contexte à l'aide de 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 • Collecte (Fan-In) : fusion des résultats

Fusionnez plusieurs canaux de sortie en un seul à l'aide de goroutines et de select pour l'agrégation des résultats. Complète le modèle de distribution/collecte pour la collecte de charges de travail parallèles.

Leçon 2 • Distribution (Fan-Out) : répartition du travail

Distribuez un seul canal d'entrée entre plusieurs goroutines de travail pour paralléliser le traitement. S'appuie sur les fondamentaux du pipeline pour exploiter le matériel multicœur.

Leçon 3 • Limitation du débit dans les pipelines

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

Leçon 4 • Modèle du générateur

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

Leçon 1 • Dimensionnement dynamique du pool

Ajustez le nombre de travailleurs à l'exécution en fonction de la profondeur de la file d'attente et des mesures 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 une répartition de travaux ordonnée par priorité à l'aide de files d'attente 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 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 travailleurs à des courtiers de messages externes pour une livraison de travaux durable avec garantie « au moins une fois ». Fait le pont entre la concurrence en mémoire 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 par 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 • Vivacité et famine

Distinguez la vivacité de l'interblocage et identifiez la famine dans l'ordonnancement des goroutines. Équipe les étudiants 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 des rapports de courses complexes. Passe de la détection de base à 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 d'attente sans verrou à l'aide de primitives atomiques comparer-et-échanger. 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 rendement mesurables.

Leçon 3 • Analyse comparative de code concurrent

Écrivez des benchmarks concurrents fiables à l'aide de testing.B et évitez les pièges de mesure courants. Assure que les affirmations de rendement 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 fin pour minimiser la contention sur les mutex. Améliore directement le débit dans les services à haute concurrence mesuré lors du profilage précédent.