Rumah  >  Artikel  >  pembangunan bahagian belakang  >  Bagaimanakah anda boleh mengehadkan bilangan rutin Go serentak apabila memproses senarai URL semasa menggunakan goroutine?

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

Mary-Kate Olsen
Mary-Kate Olsenasal
2024-10-31 11:31:02380semak imbas

How can you limit the number of concurrent Go routines when processing a list of URLs while utilizing goroutines?

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

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!

Kenyataan:
Kandungan artikel ini disumbangkan secara sukarela oleh netizen, dan hak cipta adalah milik pengarang asal. Laman web ini tidak memikul tanggungjawab undang-undang yang sepadan. Jika anda menemui sebarang kandungan yang disyaki plagiarisme atau pelanggaran, sila hubungi admin@php.cn