Limitation des goroutines
Contrôler le parallélisme
Limitation des goroutines est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.
Limiter la concurrence
Parfois, vous ne limitez pas le nombre d'opérations par seconde, mais le nombre de goroutines exécutées simultanément. Cela plafonne la charge simultanée sur une ressource, quelle que soit la répartition dans le temps.
- Limite le parallélisme
- Protège les groupes de connexions
- Évite les pics de consommation mémoire
Le canal sémaphore
Un canal mis en mémoire tampon fonctionne comme un sémaphore compteur. Sa capacité correspond au niveau maximal de concurrence. L'acquisition envoie un jeton ; la libération en reçoit un.
sem := make(chan struct{}, 3)Acquérir et libérer
Avant de commencer le travail, envoyez une valeur dans le canal pour acquérir une place (l'opération est bloquée si le canal est plein). Une fois le travail terminé, recevez une valeur pour libérer la place et la rendre disponible pour une autre goroutine.
sem <- struct{}{} // acquire
// do work
<-sem // releasePourquoi struct{}
Une structure vide struct{}{} occupe zéro octet. En l'utilisant comme type d'élément du canal, vous faites du sémaphore un simple signal, sans mémoire gaspillée.
Limiter une boucle
Lancez une goroutine par tâche, mais faites-la passer par le sémaphore. Au plus cap goroutines effectuent réellement le travail en parallèle ; les autres sont bloquées lors de l'acquisition.
for _, task := range tasks {
sem <- struct{}{}
go func(t Task) {
defer func() { <-sem }()
process(t)
}(t)
}Associer avec WaitGroup
Le sémaphore limite la concurrence, mais ne vous indique pas quand tout est terminé. Associez-le à un sync.WaitGroup pour attendre la fin de toutes les tâches.
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
defer func() { <-sem }()
process(t)
}()Libérer avec defer
Libérez toujours la place dans un defer afin qu'elle soit rendue disponible même si le travail déclenche une panique ou se termine prématurément. Oublier la libération épuise les places et finit par bloquer définitivement les nouvelles acquisitions.
Une exécution limitée complète
Ce programme exécute huit tâches, avec au plus deux tâches simultanées, et affiche leur début et leur fin pour montrer la limite en action.
package main
import (
"fmt"
"sync"
"time"
)
func main() {
sem := make(chan struct{}, 2)
var wg sync.WaitGroup
for i := 0; i < 8; i++ {
wg.Add(1)
sem <- struct{}{}
go func(id int) {
defer wg.Done()
defer func() { <-sem }()
fmt.Println("start", id)
time.Sleep(20 * time.Millisecond)
fmt.Println("end", id)
}(i)
}
wg.Wait()
fmt.Println("done")
}errgroup avec SetLimit
Le paquet golang.org/x/sync/errgroup propose SetLimit pour limiter un groupe et propager la première erreur. C'est une solution plus claire dans de nombreux cas, même s'il s'agit d'un paquet externe.
Limitation et groupe de travailleurs
Un groupe de travailleurs réutilise un ensemble fixe de goroutines qui récupèrent des tâches dans une file d'attente. La limitation par sémaphore lance une goroutine par tâche, mais plafonne le nombre de goroutines actives. Les groupes sont plus économes pour un très grand nombre de tâches ; les sémaphores sont plus simples à ajouter.
Choisir la limite
Pour les appels à la base de données, définissez la limite au niveau de votre groupe de connexions ou en dessous. Pour les requêtes HTTP sortantes, faites-la correspondre à la limite de connexions de l'hôte. Une valeur trop élevée épuise les ressources ; une valeur trop faible gaspille la capacité disponible.
Vérification rapide
Testez vos connaissances sur la limitation.
Récapitulatif
Vous avez appris à limiter les goroutines :
- Un canal mis en mémoire tampon agit comme un sémaphore compteur
- Acquérir consiste à envoyer, et libérer à recevoir dans un defer
- Les éléments de type struct{} ne coûtent aucun octet
- Associez-les à WaitGroup pour attendre la fin de l'exécution
- Dimensionnez la limite en fonction de la ressource protégée
Questions Fréquemment Posées
La leçon « Limitation des goroutines » est-elle gratuite ?
Oui — le texte complet de « Limitation des goroutines » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Limitation des goroutines » ?
Contrôler le parallélisme Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Go Academy ?
Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Limitation des goroutines » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?
Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Concept du seau de jetons
- golang.org/x/time/rate
- Limitation des goroutines
- Temporisation progressive et nouvelle tentative