Satu contoh memperkenalkan kaedah golang untuk mencapai jutaan permintaan serentak

Dengan perkembangan pesat Internet, permintaan untuk konkurensi yang tinggi semakin tinggi dan lebih tinggi Bagaimana untuk meningkatkan keselarasan sistem telah menjadi isu penting yang diterokai oleh pengaturcara. Dalam bidang bahasa pengaturcaraan, golang telah menjadi bahasa pengaturcaraan konkurensi tinggi yang popular kerana ciri konkurensi yang wujud dan prestasi cemerlang. Seterusnya, kami akan memperkenalkan cara menggunakan golang untuk mencapai jutaan permintaan serentak berdasarkan kes sebenar.

Pertama sekali, bagi pemula yang baru bersentuhan dengan golang, goroutine dan saluran adalah dua konsep yang paling penting, dan ia juga merupakan teras kepada keselarasan tinggi dalam golang. Goroutine ialah benang ringan yang tidak menggunakan terlalu banyak sumber dan boleh melaksanakan berbilang goroutin pada masa yang sama untuk mencapai operasi serentak yang cekap. Saluran ialah saluran paip yang digunakan untuk komunikasi antara goroutines, yang boleh merealisasikan penghantaran data dan operasi penyegerakan.

Seterusnya, kami akan menggunakan contoh mudah untuk memahami kaedah pelaksanaan goroutine dan saluran golang. Pertama, kami menulis pelayan HTTP mudah yang boleh mendengar permintaan dan membalas respons Kodnya adalah seperti berikut:

package main

import (
    "fmt"
    "io"
    "log"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        io.WriteString(w, "Hello, World!\n")
    })
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Seterusnya, kami menggunakan goroutine dan saluran golang untuk mencapai jutaan permintaan serentak. Pertama, kita perlu membuka berbilang goroutine untuk menghantar permintaan Kodnya adalah seperti berikut:

package main

import (
    "fmt"
    "io"
    "log"
    "net/http"
    "sync"
)

func worker(url string, ch chan<- string, wg *sync.WaitGroup) {
    defer wg.Done()
    resp, err := http.Get(url)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }
    ch <- string(body)
}

func main() {
    var wg sync.WaitGroup
    ch := make(chan string)
    for i := 0; i < 1000000; i++ {
        wg.Add(1)
        go worker("https://www.example.com", ch, &wg)
    }
    go func() {
        wg.Wait()
        close(ch)
    }()
    for resp := range ch {
        fmt.Println(resp)
    }
}

Dalam kod di atas, kami mentakrifkan fungsi pekerja untuk menghantar permintaan HTTP. Dalam fungsi utama, kami membuka 1 juta goroutine Setiap goroutine akan memanggil fungsi pekerja untuk meminta antara muka https://www.example.com dan meletakkan hasil pemulangan ke dalam saluran ch. Dalam goroutine utama, kami menggunakan gelung for untuk melintasi nilai tindak balas dalam saluran ch dan mengeluarkannya ke konsol.

Perlu diingatkan bahawa sejak 1 juta goroutin dibuka, jika tiada sekatan dikenakan, sistem mungkin ranap. Oleh itu, dalam persekitaran pengeluaran sebenar, kita perlu mengawal bilangan goroutin dengan sewajarnya untuk mengelakkan tekanan yang berlebihan pada sumber sistem.

Ringkasnya, mekanisme goroutine dan saluran yang disediakan oleh golang boleh melaksanakan operasi konkurensi tinggi dengan mudah dan meningkatkan prestasi sistem dengan sangat baik. Melalui contoh mudah di atas, kita boleh mempunyai pemahaman awal tentang kaedah golang untuk mencapai berjuta-juta permintaan serentak Walau bagaimanapun, dalam persekitaran pengeluaran sebenar, adalah perlu untuk menggabungkan senario perniagaan dan sumber sistem untuk mengawal bilangan goroutine dengan sewajarnya. skala permintaan serentak, untuk mencapai hasil prestasi yang optimum.

Atas ialah kandungan terperinci Satu contoh memperkenalkan kaedah golang untuk mencapai jutaan permintaan serentak. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!