golang permintaan serentak

Dalam aplikasi web moden, permintaan rangkaian adalah bahagian yang penting. Dengan permintaan rangkaian, kami boleh mendapatkan dan menghantar data dengan mudah. Walau bagaimanapun, apabila saiz aplikasi terus meningkat, bilangan permintaan juga akan meningkat. Dalam kes ini, bagaimana untuk memastikan kestabilan dan kecekapan sistem menjadi sangat penting.

Bahasa Go ialah bahasa pengaturcaraan serentak yang cekap dengan pengurusan memori dan kawalan serentak yang baik, jadi ia sangat baik dalam mengendalikan permintaan serentak yang tinggi. Artikel ini memperkenalkan cara menggunakan bahasa Go untuk mengendalikan permintaan serentak.

1. Mengendalikan permintaan secara serentak

Secara umumnya, permintaan rangkaian terdiri daripada tiga langkah: mewujudkan sambungan, menghantar permintaan dan menerima respons. Dalam aplikasi tradisional, setiap permintaan diteruskan melalui tiga langkah ini. Walau bagaimanapun, dalam aplikasi konkurensi tinggi, pendekatan ini tidak cekap kerana setiap permintaan perlu menunggu permintaan sebelumnya selesai sebelum ia boleh memulakan pelaksanaan.

Berikut ialah pendekatan yang berbeza. Kami boleh menggunakan ciri konkurensi bahasa Go untuk melaksanakan berbilang permintaan pada masa yang sama, supaya aplikasi boleh mengendalikan berbilang permintaan pada masa yang sama.

Berikut ialah kod contoh mudah:

func main() {
    urls := []string{
        "http://example.com",
        "http://example.net",
        "http://example.org",
    }

    ch := make(chan string)

    for _, url := range urls {
        go fetch(url, ch)
    }

    for range urls {
        fmt.Println(<-ch)
    }
}

func fetch(url string, ch chan<- string) {
    resp, err := http.Get(url)
    if err != nil {
        ch <- fmt.Sprint(err)
        return
    }
    defer resp.Body.Close()

    text, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        ch <- fmt.Sprint(err)
        return
    }

    ch <- fmt.Sprintf("url:%s, body:%s", url, text[:100])
}

Dalam contoh ini, kami mentakrifkan kepingan yang mengandungi berbilang URL. Kami kemudian membuat saluran penimbal dan menggunakan kata kunci go untuk memulakan goroutine yang mengendalikan setiap permintaan secara serentak. Dalam goroutine, kami melakukan langkah yang sama seperti mengendalikan satu permintaan dan menggunakan saluran untuk menghantar hasil kembali ke program utama. Akhir sekali, kami menggunakan gelung for range yang mudah untuk menunggu semua permintaan selesai dan mencetak hasilnya.

2. Kawal jumlah konkurensi

Dalam contoh di atas, kami menggunakan goroutine untuk memproses berbilang permintaan secara serentak. Walau bagaimanapun, berbuat demikian boleh menyebabkan sistem disekat oleh terlalu banyak permintaan dan ranap sistem. Untuk mengelakkan keadaan ini, kita perlu mengawal jumlah konkurensi.

Dalam bahasa Go, struktur sync dalam pakej WaitGroup boleh menyelesaikan masalah ini dengan baik. Struktur ini membolehkan kami meningkatkan jumlah konkurensi dalam blok kod dan menunggu semua tugasan selesai sebelum meneruskan. Berikut ialah kod contoh mudah:

func main() {
    urls := []string{
        "http://example.com",
        "http://example.net",
        "http://example.org",
    }

    var wg sync.WaitGroup

    for _, url := range urls {
        wg.Add(1)
        go func(url string) {
            defer wg.Done()

            resp, err := http.Get(url)
            if err != nil {
                fmt.Println(err)
                return
            }
            defer resp.Body.Close()

            body, err := ioutil.ReadAll(resp.Body)
            if err != nil {
                fmt.Println(err)
                return
            }

            fmt.Printf("url:%s, body:%s", url, body[:20])
        }(url)
    }

    wg.Wait()
}

Dalam contoh ini, kita mula-mula mentakrifkan pembolehubah WaitGroup. Dalam gelung, kami menggunakan kaedah Add untuk menambah kiraan serentak. Kemudian, kami memulakan goroutine untuk mengendalikan setiap permintaan. Akhir sekali, kami menggunakan kaedah Wait untuk menunggu semua goroutine selesai dan menyambung semula pelaksanaan.

3. Secara serentak memproses hasil permintaan

Apabila memproses berbilang permintaan, kita bukan sahaja perlu mengawal jumlah konkurensi, tetapi juga perlu mengendalikan hasil serentak. Secara umumnya, kita perlu mengumpulkan hasil semua permintaan ke dalam tatasusunan atau struktur data lain dan memprosesnya selepas semua permintaan selesai.

Dalam bahasa Go, kita boleh menggunakan struktur sync dalam pakej Mutex untuk mengatur akses berbilang goroutine kepada struktur data. MutexIa boleh menghalang berbilang goroutine daripada mengubah suai sumber dikongsi pada masa yang sama dan memastikan bahawa hanya satu goroutine boleh mengaksesnya pada masa yang sama.

Berikut ialah contoh kod:

type Result struct {
    url string
    body []byte
    err error
}

func fetch(url string, ch chan<- Result) {
    resp, err := http.Get(url)
    if err != nil {
        ch <- Result{url: url, err: err}
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        ch <- Result{url: url, err: err}
        return
    }

    ch <- Result{url: url, body: body}
}
func main() {
    urls := []string{
        "http://example.com",
        "http://example.net",
        "http://example.org",
    }

    var results []Result
    ch := make(chan Result)

    for _, url := range urls {
        go fetch(url, ch)
    }

    for range urls {
        results = append(results, <-ch)
    }

    for _, result := range results {
        if result.err != nil {
            fmt.Println(result.err)
            continue
        }
        fmt.Printf("url:%s, body:%s", result.url, result.body[:20])
    }
}

Dalam contoh ini, kami mentakrifkan struktur Result untuk menyimpan nilai pulangan setiap permintaan. Kami kemudian mencipta saluran penimbal dan menggunakan goroutine untuk melaksanakan setiap permintaan secara serentak. Dalam goroutine, kami menggunakan Mutex untuk memastikan sumber yang dikongsi tidak diakses oleh berbilang goroutine pada masa yang sama. Akhir sekali, kami menggunakan gelung untuk menunggu semua permintaan selesai dan mengumpul keputusan ke dalam tatasusunan. Akhir sekali, kami mengulangi tatasusunan hasil dan mencetak nilai pulangan setiap permintaan.

Ringkasan

Menggunakan bahasa Go untuk mengendalikan permintaan serentak boleh meningkatkan kecekapan dan kebolehpercayaan sistem dengan banyak. Apabila aplikasi perlu mengendalikan sejumlah besar permintaan, kita harus menggunakan goroutine dan saluran untuk melaksanakan permintaan secara serentak, dan menggunakan WaitGroup dan Mutex untuk mengawal jumlah penyelarasan dan melindungi sumber yang dikongsi. Dengan cara ini, kami boleh mengendalikan sejumlah besar permintaan dengan mudah dan cekap, meningkatkan prestasi dan kestabilan aplikasi.

Atas ialah kandungan terperinci golang permintaan serentak. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!