Comment peut-on lancer et gérer efficacement un grand nombre de goroutines, par exemple, environ 100 000 ?

Pour lancer et gérer efficacement environ 100 000 goroutines en Go, il est important de prendre en compte plusieurs aspects:

1. Utilisation d'un pool de workers — au lieu de lancer toutes les goroutines en même temps, créez un pool de taille fixe (par exemple, quelques centaines) et répartissez les tâches entre eux. Cela réduit la charge sur le planificateur et diminue la consommation de mémoire.

2. Contrôle des ressources — les goroutines sont légères, mais chacune utilise une pile (par défaut, plusieurs kilo-octets), il est donc important d'éviter de lancer trop de goroutines simultanément sans contrôle.

3. Utilisation de canaux pour la synchronisation — pour gérer le cycle de vie des goroutines et le transfert de données entre elles.

4. Contexte (context.Context) — pour les annulations et les délais d'attente.

Exemple d'un simple pool de workers:

package main

import (
    "fmt"
    "sync"
)

func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    for j := range jobs {
        // Traitement de la tâche
        results <- j * 2
    }
}

func main() {
    const numJobs = 100000
    const numWorkers = 100

    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    var wg sync.WaitGroup

    for w := 1; w <= numWorkers; w++ {
        wg.Add(1)
        go worker(w, jobs, results, &wg)
    }

    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    wg.Wait()
    close(results)

    // Traitement des résultats
    count := 0
    for r := range results {
        _ = r // utiliser le résultat
        count++
    }
    fmt.Println("Tâches traitées:", count)
}

Cette approche permet de gérer efficacement un grand nombre de tâches avec un nombre limité de goroutines.