Cara menggunakan konteks untuk melaksanakan kawalan konkurensi permintaan dalam Go

Cara menggunakan konteks untuk melaksanakan kawalan konkurensi permintaan dalam Go

Ikhtisar:
Konkurensi (concurrency) dalam bahasa Go ialah salah satu ciri terpentingnya. Menggunakan concurrency boleh meningkatkan prestasi dan responsif program anda dengan ketara, terutamanya apabila membuat permintaan rangkaian. Walau bagaimanapun, dalam senario konkurensi tinggi, masalah boleh timbul dengan mudah Contohnya, terlalu banyak permintaan serentak boleh menyebabkan kehabisan sumber. Untuk menyelesaikan masalah ini, Go menyediakan pakej konteks untuk mengurus kitaran hayat permintaan dan melaksanakan kawalan permintaan serentak. Artikel ini akan memperkenalkan cara menggunakan konteks untuk melaksanakan kawalan konkurensi permintaan dalam Go.

Gunakan konteks untuk mencipta konteks permintaan:
Pertama, kita perlu menggunakan konteks untuk mencipta konteks permintaan untuk menjejak dan mengawalnya sepanjang kitaran hayat permintaan. Anda boleh menggunakan fungsi WithCancel, WithDeadline, WithTimeout dan WithValue dalam pakej konteks untuk mencipta konteks. Contohnya, menggunakan fungsi WithCancel anda boleh mencipta konteks yang boleh dibatalkan:

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

Dalam contoh ini, kami menggunakan fungsi WithCancel untuk mencipta konteks yang boleh dibatalkan dan memanggil fungsi cancel untuk melepaskan sumber selepas permintaan berakhir.

Kawal bilangan permintaan serentak:
Untuk mengawal permintaan serentak, kami boleh menggunakan mekanisme goroutine dan saluran bahasa Go. Kami boleh memulakan berbilang goroutine untuk mengendalikan permintaan dan menggunakan saluran untuk mengehadkan bilangan permintaan serentak.

func main() {
    urls := []string{"http://url1.com", "http://url2.com", "http://url3.com", ...}

    maxConcurrency := 5
    sem := make(chan struct{}, maxConcurrency)

    for _, url := range urls {
        sem <- struct{}{}

        go func(url string) {
            defer func() {
                <-sem
            }()

            makeRequest(url)
        }(url)
    }

    // 等待所有请求完成
    for i := 0; i < maxConcurrency; i++ {
        sem <- struct{}{}
    }
}

func makeRequest(url string) {
    // 创建请求的上下文
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        log.Printf("Error creating request: %s", err.Error())
        return
    }

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        log.Printf("Error making request: %s", err.Error())
        return
    }

    defer resp.Body.Close()

    // 处理响应
    // ...
}

Dalam contoh di atas, kami menggunakan goroutine untuk mengendalikan setiap permintaan. Untuk mengehadkan bilangan permintaan serentak, kami mencipta saluran dengan penimbal dan menghantar nilai ke saluran pada permulaan setiap goroutine. Pada penghujung goroutine, kami menerima nilai daripada saluran untuk membebaskan slot. Dengan mengawal bilangan slot dalam saluran, kami boleh mengehadkan bilangan permintaan serentak.

Gunakan konteks untuk melaksanakan kawalan tamat masa permintaan:
Kadangkala, kami mungkin perlu menetapkan tamat masa untuk permintaan itu bagi mengelakkan permintaan daripada dibalas terlalu lama. Dalam Go, anda boleh menggunakan fungsi WithTimeout konteks untuk menetapkan tamat masa permintaan. Berikut ialah contoh:

func main() {
    url := "http://url.com"

    ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
    defer cancel()

    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        log.Printf("Error creating request: %s", err.Error())
        return
    }

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        log.Printf("Error making request: %s", err.Error())
        return
    }

    defer resp.Body.Close()

    // 处理响应
    // ...
}

Dalam contoh ini, kami mencipta konteks dengan tamat masa 5 saat menggunakan fungsi WithTimeout. Sebelum memanggil kaedah Do untuk menghantar permintaan, kami menyampaikan konteks ini kepada kaedah NewRequestWithContext. Jika permintaan tidak menerima respons selama lebih daripada 5 saat, konteks akan dibatalkan secara automatik.

Ringkasan:
Dalam bahasa Go, menggunakan konteks boleh mengurus kitaran hayat permintaan dengan mudah dan mengawal bilangan permintaan serentak dan tamat masa. Dengan menggunakan mekanisme secara fleksibel seperti concurrency, saluran dan konteks, kami boleh mencapai pemprosesan permintaan yang lebih cekap dan boleh dipercayai dalam senario concurrency tinggi.

Nota:
Walaupun dalam artikel ini, kami terutamanya memperkenalkan cara menggunakan konteks untuk melaksanakan kawalan konkurensi permintaan, untuk senario yang lebih kompleks, seperti permintaan cuba semula, pembatalan berbilang permintaan serentak, dsb., anda juga boleh menggunakan fungsi konteks yang lain . Adalah disyorkan untuk membaca pengenalan terperinci tentang konteks dalam dokumentasi bahasa Go rasmi untuk mengetahui lebih banyak penggunaan dan amalan terbaik.

Atas ialah kandungan terperinci Cara menggunakan konteks untuk melaksanakan kawalan konkurensi permintaan dalam Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!