Comment maintenir un nombre fixe de goroutines simultanées dans Go ?

Maintenir un nombre fixe de goroutines simultanées

Dans Go, vous pouvez rencontrer des scénarios dans lesquels le contrôle du nombre de goroutines exécutées simultanément est crucial. Alors que les didacticiels se concentrent souvent sur l'attente de la fin des goroutines, atteindre un nombre spécifique de goroutines actives à un moment donné présente un défi différent.

Considérez la situation suivante : vous avez des centaines de milliers de tâches à traiter. Le traitement de chaque tâche nécessite sa propre goroutine, mais vos ressources système ne peuvent gérer qu'un maximum de 20 goroutines simultanées. Vous devez vous assurer qu'il y a toujours 20 goroutines en cours d'exécution, et en lancer une nouvelle chaque fois qu'une goroutine existante est terminée.

Parallélisme limité

Pour y parvenir, les modèles de concurrence Go L'article suggère d'utiliser un modèle appelé « parallélisme limité ». Cela implique d'utiliser un canal de structures vides comme garde pour limiter le nombre de travailleurs simultanés.

Implémentation

Voici un exemple qui montre comment implémenter ce modèle :

package main

import (
    "fmt"
    "sync"
)

func main() {
    const maxGoroutines = 20

    // Create a channel of empty structs to control worker count
    guard := make(chan struct{}, maxGoroutines)

    var wg sync.WaitGroup

    // Launch workers
    for i := 0; i < 30; i++ {
        wg.Add(1)
        guard <- struct{}{} // Blocks if guard channel is filled
        go func(n int) {
            defer wg.Done()
            worker(n)
            <-guard // Release slot in guard channel
        }(i)
    }
    wg.Wait()
}

func worker(i int) { fmt.Println("doing work on", i) }

Dans cet exemple, le canal de garde est utilisé comme compartiment de jetons. Le nombre maximum de goroutines pouvant s'exécuter simultanément est limité par la capacité du canal (20 dans ce cas). Chaque goroutine acquiert un « jeton » (une structure vide) du canal avant de commencer le travail. Lorsqu'une goroutine termine, elle libère son jeton dans le canal, le rendant disponible pour qu'une autre goroutine puisse l'acquérir. En contrôlant le nombre de jetons dans le canal, vous contrôlez efficacement le nombre de goroutines simultanées.

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!