Wie können Sie die Anzahl gleichzeitiger Go-Routinen begrenzen, wenn Sie eine Liste von URLs verarbeiten und dabei Goroutinen verwenden?

Begrenzung der Anzahl gleichzeitiger Go-Routinen

Problem:
Sie beabsichtigen, eine Liste von URLs zu verarbeiten gleichzeitige Verwendung von Goroutinen, jedoch mit einer vordefinierten maximalen Anzahl von Goroutinen, die gleichzeitig ausgeführt werden. In diesem Fall möchten Sie die Parallelisierung auf zehn Goroutinen gleichzeitig beschränken, obwohl Sie dreißig URLs haben.

Lösung:

Der Schlüssel zur Lösung dieses Problems liegt in der Änderung der Architektur Ihres Codes. Anstatt für jede URL eine separate Goroutine zu erstellen, generieren Sie eine begrenzte Anzahl von Worker-Goroutinen, die URLs aus einem gemeinsamen Kanal nutzen. Die gepufferte Natur dieses Kanals reguliert die Parallelität.

Codeänderung:

Hier ist eine aktualisierte Version Ihres Codes, die diesen Ansatz beinhaltet:

<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>

In diesem überarbeiteten Code:

1. Ein gepufferter Kanal, urlsChan, wird erstellt, um die zu verarbeitenden URLs zu speichern. Die Puffergröße ist auf *parallel eingestellt, wodurch die Anzahl der Goroutinen, die gleichzeitig auf den Kanal zugreifen können, effektiv begrenzt wird.
2. Eine separate Goroutine ist für das Auffüllen des urlsChan-Kanals mit URLs zuständig.
3. Die Worker-Goroutinen Verbrauchen Sie kontinuierlich URLs aus dem urlsChan-Kanal, bis dieser geschlossen wird.
4. Eine separate Goroutine wird verwendet, um den Ergebniskanal zu schließen, sobald alle Mitarbeiter ihre Aufgaben abgeschlossen haben.

Durch die Nutzung dieser modifizierten Architektur , können Sie die Anzahl der gleichzeitig ausgeführten Goroutinen basierend auf dem angegebenen Parallelitätslimit effektiv regulieren.

Das obige ist der detaillierte Inhalt vonWie können Sie die Anzahl gleichzeitiger Go-Routinen begrenzen, wenn Sie eine Liste von URLs verarbeiten und dabei Goroutinen verwenden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!