0Pricing
Go Academy · Leçon

Modèle du sémaphore

Limiter la concurrence avec un canal sémaphore

Modèle du sémaphore 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.

Qu'est-ce qu'un sémaphore ?

Un sémaphore limite le nombre de goroutines qui effectuent simultanément une opération. Il évite l'épuisement des ressources (par exemple, un trop grand nombre de connexions ouvertes à une base de données ou de requêtes HTTP sortantes).

Canal avec tampon utilisé comme sémaphore

Un canal avec tampon d'une capacité N agit comme un sémaphore compteur. L'acquisition consiste à envoyer une valeur dans le canal (ce qui bloque lorsqu'il est plein) ; la libération consiste à en recevoir une.

sem := make(chan struct{}, 10)

func withSem(f func()) {
    sem <- struct{}{} // acquire
    defer func() { <-sem }() // release
    f()
}

Une goroutine par tâche avec un sémaphore

Lancez une goroutine par tâche, mais limitez la concurrence avec un sémaphore :

sem := make(chan struct{}, 5)
for _, job := range jobs {
    sem <- struct{}{}
    go func(j Job) {
        defer func() { <-sem }()
        process(j)
    }(job)
}

Vider le sémaphore à la fin

Après avoir lancé toutes les goroutines, videz le sémaphore pour vous assurer qu'elles sont toutes terminées avant le retour :

// After the loop, acquire all N slots (blocks until all goroutines release)
for i := 0; i < cap(sem); i++ {
    sem <- struct{}{}
}

golang.org/x/sync/semaphore

Pour un sémaphore pondéré (par exemple, lorsque les goroutines ont des poids de ressources différents), utilisez le type semaphore.Weighted :

s := semaphore.NewWeighted(100)
// acquire 10 units
if err := s.Acquire(ctx, 10); err != nil { return err }
defer s.Release(10)
// do work

Acquisition tenant compte du contexte

L'Acquire du sémaphore pondéré respecte un contexte et renvoie une erreur s'il est annulé avant que le sémaphore soit disponible.

TryAcquire

s.TryAcquire(n) acquiert n unités uniquement si elles sont immédiatement disponibles et renvoie false dans le cas contraire. Cette fonction est utile pour les vérifications non bloquantes.

Sémaphore ou groupe de travailleurs

Un groupe de travailleurs possède un ensemble fixe de goroutines persistantes. Un sémaphore permet de lancer des goroutines à la demande tout en plafonnant la concurrence. Utilisez un sémaphore lorsque le rythme d'arrivée des tâches varie fortement.

Limitation de la concurrence HTTP

Enveloppez un gestionnaire ou un client HTTP dans un sémaphore afin d'éviter un trop grand nombre de requêtes sortantes simultanées ou de goroutines de gestion entrantes.

Limitation des connexions à la base de données

Au lieu d'utiliser un sémaphore, définissez db.SetMaxOpenConns(n) et db.SetMaxIdleConns(m) — le paquet sql gère en interne la concurrence du pool de connexions.

Équité du sémaphore

Les sémaphores fondés sur des canaux avec tampon sont approximativement équitables (FIFO pour les goroutines bloquées lors de l'envoi), mais cette équité n'est pas strictement garantie. Le paquet de sémaphore pondéré fournit des garanties d'équité plus strictes.

Vérification rapide

Comment un canal tamponné implémente-t-il un sémaphore ?

Récapitulatif&nbsp;: modèle du sémaphore

Points essentiels :

  • Le canal tamponné sem := make(chan struct{}, N) convient aux sémaphores simples
  • Envoyez une valeur pour acquérir le sémaphore ; recevez-en une pour le libérer ; utilisez toujours defer pour garantir la libération
  • golang.org/x/sync/semaphore pour une variante pondérée prenant en compte le contexte
  • Utilisez errgroup.SetLimit pour limiter simplement la concurrence par groupe

Questions Fréquemment Posées

La leçon « Modèle du sémaphore » est-elle gratuite ?

Oui — le texte complet de « Modèle du sémaphore » 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 « Modèle du sémaphore » ?

Limiter la concurrence avec un canal sémaphore 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 « Modèle du sémaphore » ?

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

  1. Modèles de pipeline et d’étapes
  2. errgroup pour la gestion concurrente des erreurs
  3. Modèle du sémaphore
  4. Détection des fuites et annulation
← Retour à Go Academy