Comment peut-on contrôler le nombre de threads actifs dans une application?

En Go, pour contrôler le nombre de threads actifs (goroutines), on utilise généralement des mécanismes de synchronisation et de limitation du parallélisme :

• Canaux tamponnés comme sémaphores : créent un canal avec une capacité limitée et, avant de lancer une goroutine, y envoient une valeur, et après sa fin, en reçoivent une, limitant ainsi le nombre de goroutines en cours.

• Package sync.WaitGroup : aide à attendre la fin d'un groupe de goroutines, mais ne limite pas leur nombre.

• Package golang.org/x/sync/semaphore : fournit un sémaphore pratique pour limiter le parallélisme.

Exemple avec un canal-sémaphore :

sem := make(chan struct{}, 5) // maximum 5 goroutines en même temps

for _, task := range tasks {
    sem <- struct{}{} // bloque si déjà 5 goroutines en cours
    go func(t Task) {
        defer func() { <-sem }() // libère une place
        process(t)
    }(task)
}

// Attend que toutes les goroutines se terminent
for i := 0; i < cap(sem); i++ {
    sem <- struct{}{}
}

Ainsi, il est possible de contrôler le nombre de threads actifs et d'éviter une consommation excessive de ressources.