Goroutines et canaux : modèles de concurrence dans Go

La concurrence nous permet de gérer plusieurs tâches indépendamment les unes des autres. Les Goroutines sont un moyen simple de traiter plusieurs tâches de manière indépendante. Dans cet article, nous améliorons progressivement un gestionnaire http qui accepte les fichiers et explore divers modèles de concurrence dans Go en utilisant les canaux et le package de synchronisation.

Installation

Avant d’entrer dans les modèles de concurrence, préparons le terrain. Imaginez que nous ayons un gestionnaire HTTP qui accepte plusieurs fichiers via un formulaire et traite les fichiers d'une manière ou d'une autre.

func processFile(file multipart.File) {
   // do something with the file
   fmt.Println("Processing file...")
   time.Sleep(100 * time.Millisecond) // Simulating file processing time
}
func UploadHandler(w http.ResponseWriter, r *http.Request) {
   // limit to 10mb 
   if err := r.ParseMultipartForm(10 



<p>Dans l'exemple ci-dessus, nous recevons des fichiers d'un formulaire et les traitons séquentiellement. Si 10 fichiers sont téléchargés, cela prendrait 1 seconde pour terminer le processus et envoyer une réponse au client. <br>
Lors du traitement de nombreux fichiers, cela peut devenir un goulot d'étranglement, mais avec la prise en charge de la concurrence de Go, nous pouvons facilement résoudre ce problème.</p>
<h2>
  
  
  Groupes d'attente
</h2>

<p>Pour résoudre ce problème, nous pouvons traiter les fichiers simultanément. Pour générer une nouvelle goroutine, nous pouvons préfixer un appel de fonction avec le mot-clé go, par exemple. allez processFile (f). Cependant, comme les goroutines ne bloquent pas, le gestionnaire peut revenir avant la fin du processus, laissant les fichiers éventuellement non traités ou renvoyant un état incorrect. Pour attendre le traitement de tous les fichiers, nous pouvons utiliser sync.WaitGroup.<br>
Un WaitGroup attend la fin d'un certain nombre de goroutines, pour chaque goroutine que nous générons, nous devons également augmenter le compteur dans le WaitGroup, cela peut être fait avec la fonction Ajouter. Lorsqu'une goroutine est terminée, Done doit être appelé pour que le compteur soit diminué de un. Avant de revenir de la fonction Wait, il faut appeler ce qui bloque jusqu'à ce que le compteur du WaitGroup soit 0.<br>
</p>

<pre class="brush:php;toolbar:false">func UploadHandler(w http.ResponseWriter, r *http.Request) {
   if err := r.ParseMultipartForm(10 



<p>Maintenant, pour chaque fichier téléchargé, une nouvelle goroutine est générée, ce qui pourrait submerger le système. Une solution consiste à limiter le nombre de goroutines générées.</p>

<h2>
  
  
  Limiter la concurrence avec un sémaphore
</h2>

<p>Un sémaphore n'est qu'une variable que nous pouvons utiliser pour contrôler l'accès aux ressources communes par plusieurs threads ou dans ce cas, des goroutines.<br><br>
En Go, nous pouvons utiliser des canaux tamponnés pour implémenter un sémaphore.</p>
<h3>
  
  
  Canaux
</h3>

<p>Avant de commencer l'implémentation, regardons ce que sont les canaux et la différence entre les canaux avec et sans tampon. </p>

<p>Les canaux sont un canal à travers lequel nous pouvons envoyer et recevoir des données pour communiquer en toute sécurité entre les routines Go.<br>
Les chaînes doivent être créées avec la fonction make.<br>
</p><pre class="brush:php;toolbar:false">
func processFile(file multipart.File) {
   // do something with the file
   fmt.Println("Processing file...")
   time.Sleep(100 * time.Millisecond) // Simulating file processing time
}
func UploadHandler(w http.ResponseWriter, r *http.Request) {
   // limit to 10mb 
   if err := r.ParseMultipartForm(10 



<p>Les chaînes ont un opérateur spécial 
Le fait que l'opérateur pointe sur le canal ch <br>
<img src="/static/imghwm/default1.png" data-src="https://img.php.cn/upload/article/000/000/000/173404051364120.jpg?x-oss-process=image/resize,p_40" class="lazy" alt="Goroutines and Channels: Concurrency Patterns in Go"><br>
L'animation visualise un producteur envoyant la valeur 1 via un canal sans tampon et le consommateur lisant depuis le canal.</p>

<p>Si le producteur peut envoyer des événements plus rapidement que le consommateur ne peut les gérer, nous avons la possibilité d'utiliser un <strong>canal tamponné</strong> pour mettre en file d'attente plusieurs messages sans bloquer le producteur jusqu'à ce que le tampon soit plein. Dans le même temps, le consommateur peut gérer les messages à son propre rythme.<br>
</p>

<pre class="brush:php;toolbar:false">func UploadHandler(w http.ResponseWriter, r *http.Request) {
   if err := r.ParseMultipartForm(10 



<p>Dans cet exemple, le producteur peut envoyer jusqu'à deux articles sans bloquer. Lorsque la capacité du tampon est atteinte, le producteur bloquera jusqu'à ce que le consommateur traite au moins un message. </p>

<p><img src="/static/imghwm/default1.png" data-src="https://img.php.cn/upload/article/000/000/000/173404051459967.jpg?x-oss-process=image/resize,p_40" class="lazy" alt="Goroutines and Channels: Concurrency Patterns in Go"></p>

<p>Retour au problème initial, nous voulons limiter le nombre de goroutines traitant des fichiers simultanément. Pour ce faire, nous pouvons utiliser des canaux tamponnés.<br>
</p>

<pre class="brush:php;toolbar:false">ch := make(chan int)

Dans cet exemple nous avons ajouté un canal tamponné d'une capacité de 5, cela nous permet de traiter 5 fichiers simultanément et de limiter la pression sur le système.

Mais et si tous les fichiers ne sont pas égaux ? Nous pouvons prédire de manière fiable que différents types ou tailles de fichiers nécessitent plus de ressources pour être traités. Dans ce cas, nous pouvons utiliser un sémaphore pondéré.

Sémaphore pondéré

En termes simples, avec un sémaphore pondéré, nous pouvons attribuer plus de ressources à une seule tâche. Go fournit déjà une implémentation pour un sémaphore pondéré dans le package extend sync.

ch := make(chan int, 2)

Dans cette version, nous avons créé un sémaphore pondéré avec 5 emplacements. Si seules des images sont téléchargées, par exemple, le processus gère 5 images simultanément. Cependant, si un PDF est téléchargé, 2 emplacements sont acquis, ce qui réduirait la quantité de fichiers pouvant être gérés. en même temps.

Conclusion

Nous avons exploré quelques modèles de concurrence dans Go, en utilisant sync.WaitGroup et des sémaphores pour contrôler le nombre de tâches simultanées. Cependant, il existe davantage d'outils disponibles, nous pourrions utiliser des canaux pour créer un pool de travailleurs, ajouter des délais d'attente ou utiliser un modèle d'entrée/sortie de ventilateur.
De plus, la gestion des erreurs est un aspect important qui a été largement laissé de côté par souci de simplicité.
Une façon de gérer les erreurs consisterait à utiliser des canaux pour regrouper les erreurs et les gérer une fois toutes les goroutines terminées.

Go fournit également un errgroup.Group qui est lié à sync.WaitGroups mais ajoute la gestion des tâches qui renvoient des erreurs.
Le package se trouve dans le package extend sync.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!