Comment déterminer la limite du nombre de goroutines exécutées simultanément dans le langage Go ?

Dans le langage Go, il n'existe pas de mécanisme intégré pour limiter directement le nombre de goroutines en cours d'exécution simultanément. Cependant, pour contrôler la limite de parallélisme, on utilise généralement des sémaphores ou des canaux avec une capacité limitée.

Exemple de limitation du nombre de goroutines en cours d'exécution simultanément à l'aide d'un canal :

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, sem chan struct{}, wg *sync.WaitGroup) {
    defer wg.Done()
    sem <- struct{}{} // acquérir une place
    fmt.Printf("Goroutine %d a commencé\n", id)
    time.Sleep(time.Second) // simulation de travail
    fmt.Printf("Goroutine %d a terminé\n", id)
    <-sem // libérer une place
}

func main() {
    const maxGoroutines = 3
    sem := make(chan struct{}, maxGoroutines) // canal avec tampon limite le nombre de goroutines
    var wg sync.WaitGroup

    for i := 1; i <= 10; i++ {
        wg.Add(1)
        go worker(i, sem, &wg)
    }
    wg.Wait()
}

Dans cet exemple, le canal sem avec un tampon de maxGoroutines limite le nombre de goroutines en cours d'exécution simultanément. Chaque goroutine, avant de commencer à travailler, place une structure vide dans le canal, occupant une place, et la libère après avoir terminé. Ainsi, pas plus de maxGoroutines goroutines ne fonctionneront en même temps.