Formation Programmation concurrente en Go

La programmation concurrente, ou l'art de composer un programme de manière à délinéer les tâches indépendantes, est l'une des forces du langage Go. Cependant, la tentation de nombre de développeur·se·s débutant·e·s en Go est de se lancer éperdument dans la programmation concurrente sans en maîtriser les fondamentaux, au risque de l'utiliser à mauvais escient.

Lors de cette formation ludique, vous apprendrez à dompter la programmation concurrente en Go. Une série de métaphores tournant autour du thème de la cuisine vous aideront à appréhender certains concepts difficiles de prime abord. A l'issue de la formation, les goroutines, les canaux (channels), et l'instruction select n'auront désormais plus de secrets pour vous.

Cette formation s'adresse à tous·tes développeur·se·s maîtrisant les bases du langage Go et qui n'ont pas (ou peu) été exposé·e·s à la programmation concurrente en Go. Si toutefois vous démarrez en Go, notre formation Go adressée aux débutant·e·s est faite pour vous.

Au fil de l'amélioration d'un projet pré-existant, un petit utilitaire permettant de vérifier la validité et la disponibilité d'un nom sur plusieurs réseaux sociaux (GitHub, Reddit, etc.), vous serez acteur·rice·s de la formation. Vous lancerez vos propres goroutines afin d'effectuer de manière concurrente des traitements initialement séquentiels ; vous communiquerez les résultats de certaines goroutines à d'autres grâce à des canaux ; vous apprendrez pourquoi et comment rendre vos goroutines annulables ; enfin, vous comprendrez comment sérialiser l'accès à de la mémoire partagée via une exclusion mutuelle (mutex).

Toutes nos formations étant limitées à 6 participant·e·s par session, vous aurez un contact privilégié avec votre formateur, Julien Cretel, Gopher passionné et pédagogue, enthousiaste de partager ses expériences professionnelles lors des moments informels de cette formation.

Envie de passer au niveau supérieur ?
Jetez un œil à la formation Go Avancé, également animée par Julien Cretel. Vous y apprendrez des bonnes pratiques de conception de bibliothèques, des patrons (patterns) de concurrence à la puissance insoupçonnée, ainsi que le profilage et l'optimisation de performance de vos applications Go.

Les objectifs

• Maîtriser les fondamentaux de la programmation concurrente en Go
• Reconnaitre les bons des mauvais cas d'utilisation de la concurrence
• Améliorer un outil en ligne de commande permettant de vérifier la validité et la disponibilité d'un nom sur plusieurs réseaux sociaux (GitHub, Reddit, etc.)
• Faire évoluer l'outil en ligne de commande en une API HTTP et poursuivre son amélioration

Pré-requis

• Une expérience soutenue d'au moins quelques mois avec Go (sans forcément avoir touché à la programmation concurrente)
• Des bases en anglais technique
• Installation de Go (1.21+) et Git
• Ordinateur portable à apporter

Le programme de la formation Programmation concurrente en Go

Présentation du projet fil-rouge

• namecheck : un outil en ligne de commande permettant de vérifier la validité et la disponibilité d'un nom sur plusieurs réseaux sociaux (GitHub, Reddit, etc.)
• Motivations pour le développement d'un tel outil

Mise en pratique : Utilisation de l'outil à la ligne de commande

Concurrence

• La concurrence : l'art de composer un programme de manière à délinéer les tâches indépendantes
• Concurrence et parallélisme : deux notions étroitement liées mais distinctes
• La concurrence permet le parallélisme et ouvre la porte à une plus grande vitesse d'exécution.
• Loi d'Amdahl et loi de Gunther : le parallélisme n'est pas magique !
• Le tiercé gagnant de la concurrence en Go : goroutines, canaux, et instruction select

Mise en pratique : Identification, dans le programme namecheck, de traitements séquentiels qui bénéficieraient d'une ré-écriture traitements concurrents

Goroutines

• Les goroutines : une sorte de thread "poids plume"
• L'ordonnanceur (scheduler) : la partie du runtime qui jongle avec les goroutines
• Démarrage de goroutines grâce au mot-clé go
• La règle d'or : ne démarrez une goroutine que si vous pouvez expliquer quand elle se terminera.
• La fonction main n'attend pas la fin des autres goroutines.
• Groupes d'attente (wait groups)
• Bogue de synchronisation et situations de compétition
• Concurrency safety : la garantie qu'une opération peut être effectuée de manière concurrente sans souci
• Situations de compétitions portant sur l'accès à de la mémoire partagée
• Détecteur de situations de compétition portant sur l'accès à de la mémoire partagée (option -race)
• Bogue de synchronisation dû à la portée inappropriée des variables de boucle avant Go 1.22

Mise en pratique : Vérification concurrente de la validité et disponibilité d'un nom sur de multiples réseaux sociaux

Canaux (channels) et programmation concurrente par envoi de messages

• Partage d'état ou envoi de messages : deux approches possibles pour la programmation concurrente
• Un adage incontournable en Go : Plutôt que communiquer en partageant de la mémoire, préférez partager de la mémoire en communiquant.
• Les canaux : la méthode reine pour communiquer entre goroutines et/ou les synchroniser
• Convention de nommage des canaux
• Les canaux sont des valeurs à part entière.
• Valeur vierge des canaux
• Initialisation de channels avec la fonction make
• Capacité et espace tampon d'un canal
• Les canaux fonctionnent sur le principe du "premier entré, premier sorti" (FIFO).
• L'importance de bien choisir la capacité des canaux
• Emission d'une valeur dans un canal : syntaxe et sémantique
• Réception d'une valeur d'un canal : syntaxe et sémantique
• Résoudre l'ambiguïté à la réception d'une valeur d'un canal
• Interblocage ou étreinte mortelle : quand les goroutines se bloquent entre elles
• Fuite de goroutines
• Fermeture d'un canal : syntaxe et sémantique
• Bonnes et mauvaises raisons de fermer un canal
• Réception à répétition d'un canal grâce à une boucle for-range
• Canaux unidirectionnels (émission seule ou réception seule)

Mise en pratique :
- Analyse et résolution d'un d'interblocage
- Analyse et résolution d'une fuite de goroutines
- Communication de résultats entre goroutines à l'aide d'un canal dans le but d'agréger ces résultats

Serveur HTTP

• Présentation sommaire du paquet net/http
• Présentation d'un simple serveur "Hello, World!"
• Quid des frameworks Web pour Go ?
• Méfiance : un handler fait l'objet d'invocations concurrentes par le serveur

Mise en pratique : Transformation de l'outil de ligne de commande de départ en une API HTTP

L'instruction select

• Sélecteur de communications sur canaux
• Instruction select : syntaxe et sémantique
• Boucle d'évènements : instruction select au sein d'une boucle
• Le besoin de signaler à des goroutines qu'elles doivent se terminer/s'annuler
• Quels genres de fonction rendre annulables ?
• Emission et détection d'un signal de terminaison : la technique de base
• Emission et détection d'un signal de terminaison en pratique avec le paquet context
• Comment rendre annulable l'émission d'une valeur dans un canal
• Débogage d'une simple simulation de ping-pong

Mises en pratique :
- Utilisation d'une instruction select et de deux canaux distincts, l'un dédié aux résultats et l'autre aux erreurs
- Analyse et résolution d'une fuite de goroutines

Programmation concurrente par partage d'état

• Communiquer en partageant de la mémoire
• Exclusions mutuelles (mutexes) et sections critiques
• Utilisation du type sync.Mutex

Mise en pratique : Utilisation d'une exclusion mutuelle pour la mise à jour d'une variable globale d'état

Ressources d'apprentissage

Télécharger le programme

Le(s) formateur(s)

Julien CRETEL

Julien est à la fois développeur, chercheur en sécurité Web et formateur.

Son langage de prédilection est le Go, sujet sur lequel il a formé des centaines de professionnel·le·s depuis 2019. Il lui arrive aussi d'intervenir sur Go à l'occasion de conférences spécialisées, telles que GopherCon 2023 Europe.

Julien est actif dans le domaine de la sécurité Web. En marge des tests de sécurité (tests d'intrusion, évaluation de vulnérabilité, audit de codes, etc.) que ses clients lui confient et de ses activités de recherche indépendante, Julien forme régulièrement des professionnel·le·s sur la sécurité Web. Il s'adonne aussi, de temps à autre, à la chasse au bogues de sécurité (bug bounty hunting).

Julien partage ses réflexions et sa recherche sur son blog, qui est, sans surprises, principalement dédié au langage Go et à la sécurité Web.

Voir son profil détaillé

FAQ

8 raisons de participer à une formation Human Coders

• Satisfaction client élevée : Un taux de statisfaction de 4,6/5 depuis 2012 (sur 1646 sessions réalisées). 99% des participants se disent satisfaits de nos formations
• Approche pédagogique unique : Des formations en petit groupe, des formateurs passionnés et expérimentés, de véritables workshops... (Plus d'infos sur notre manifeste)
• Catalogue de formations complet : 170 formations au catalogue, de quoi vous accompagner sur tout vos projets
• Écosystème dynamique : Nous accompagnons les dev depuis 13 ans avec des initiatives comme Human Coders News, les Human Talks, le podcast ou encore notre serveur Discord
• Financement facilité : Organisme certifié Qualiopi, indispensable pour que vous puissiez obtenir des aides au financement via votre OPCO
• Références clients prestigieuses : De nombreux clients qui nous font confiance depuis des années
• Accompagnement sur mesure : Nous vous proposons un accompagnement personnalisé par nos consultants pour vous aider dans vos projets au-delà de la formation
• Valorisation professionnelle : Remise d'un diplôme, d'une attestation et d'une certification, suivant les formations effectuées, que vous pourrez afficher sur vos CV et réseaux sociaux