Comment pouvez-vous limiter le nombre de routines Go simultanées lors du traitement d'une liste d'URL tout en utilisant des goroutines ?

Limitation du nombre de routines Go simultanées

Problème :
Vous avez l'intention de traiter une liste d'URL en utilisant simultanément des goroutines mais avec un nombre maximum prédéfini de goroutines s'exécutant simultanément. Dans ce cas, vous souhaitez restreindre la parallélisation à dix goroutines simultanément, malgré trente URL.

Solution :

La clé pour résoudre ce problème réside dans la modification du l'architecture de votre code. Au lieu de générer une goroutine distincte pour chaque URL, générez un nombre limité de goroutines de travail qui consomment les URL d'un canal partagé. La nature tamponnée de ce canal régulera la concurrence.

Modification du code :

Voici une version mise à jour de votre code qui intègre cette approche :

<code class="go">package main

import (
    "flag"
    "fmt"
    "os"
    "sync"
    "time"
)

func main() {
    parallel := flag.Int("parallel", 10, "max parallel requests allowed")
    flag.Parse()
    urls := flag.Args()

    // Create a buffered channel to buffer URLs
    urlsChan := make(chan string, *parallel)

    // Create a separate goroutine to feed URLs into the channel
    go func() {
        for _, u := range urls {
            urlsChan <- u
        }
        // Close the channel to indicate that there are no more URLs to process
        close(urlsChan)
    }()

    var wg sync.WaitGroup
    client := rest.Client{}

    results := make(chan string)

    // Start the specified number of worker goroutines
    for i := 0; i < *parallel; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            // Continuously retrieve URLs from the channel until it is closed
            for url := range urlsChan {
                worker(url, client, results)
            }
        }()
    }

    // Launch a separate goroutine to close the results channel when all workers are finished
    go func() {
        // Wait for all workers to finish processing URLs
        wg.Wait()
        // Close the results channel to signal that there are no more results
        close(results)
    }()

    // Read results from the channel until it is closed
    for res := range results {
        fmt.Println(res)
    }

    os.Exit(0)
}</code>

Dans ce code révisé :

1. Un canal tamponné, urlsChan, est créé pour contenir les URL à traiter. La taille du tampon est définie sur *parallel, limitant ainsi le nombre de goroutines pouvant accéder simultanément au canal.
2. Une goroutine distincte est dédiée au remplissage du canal urlsChan avec des URL.
3. Les goroutines de travail consomme continuellement les URL du canal urlsChan jusqu'à sa fermeture.
4. Une goroutine distincte est utilisée pour fermer le canal de résultats une fois que tous les travailleurs ont terminé leurs tâches.

En tirant parti de cette architecture modifiée , vous pouvez réguler efficacement le nombre de goroutines s'exécutant simultanément en fonction de la limite de parallélisme spécifiée.

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!