Bagaimanakah anda boleh mengehadkan bilangan rutin Go serentak apabila memproses senarai URL semasa menggunakan goroutine?

Menghadkan Bilangan Rutin Pergi Serentak

Isu:
Anda berhasrat untuk memproses senarai URL secara serentak menggunakan goroutin tetapi dengan bilangan maksimum goroutin yang dipratentukan yang dilaksanakan secara serentak. Dalam keadaan ini, anda ingin mengehadkan penyejajaran kepada sepuluh goroutin secara serentak, walaupun mempunyai tiga puluh URL.

Penyelesaian:

Kunci untuk menyelesaikan isu ini terletak pada mengubah suai seni bina kod anda. Daripada menghasilkan goroutine yang berasingan untuk setiap URL, hasilkan bilangan goroutin pekerja yang terhad yang menggunakan URL daripada saluran kongsi. Sifat penimbal saluran ini akan mengawal selia konkurensi.

Pengubahsuaian Kod:

Berikut ialah versi terkini kod anda yang menggabungkan pendekatan ini:

<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 &lt;- 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 &lt; *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>

Dalam kod yang disemak ini:

1. Saluran penimbal, urlsChan, dicipta untuk menyimpan URL yang akan diproses. Saiz penimbal ditetapkan kepada *selari, dengan berkesan mengehadkan bilangan goroutin yang boleh mengakses saluran secara serentak.
2. Groutine berasingan dikhaskan untuk mengisi saluran urlsChan dengan URL.
3. Groutine pekerja teruskan menggunakan URL daripada saluran urlsChan sehingga ia ditutup.
4. Groutine berasingan digunakan untuk menutup saluran keputusan sebaik sahaja semua pekerja menyelesaikan tugas mereka.

Dengan memanfaatkan seni bina yang diubah suai ini , anda boleh mengawal dengan berkesan bilangan goroutine yang dilaksanakan serentak berdasarkan had selari yang ditentukan.

Atas ialah kandungan terperinci Bagaimanakah anda boleh mengehadkan bilangan rutin Go serentak apabila memproses senarai URL semasa menggunakan goroutine?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!