Cara menggunakan konteks untuk melaksanakan penggabungan hasil permintaan dalam Go

Cara menggunakan konteks untuk melaksanakan penggabungan hasil permintaan dalam Go

Dalam sistem teragih moden, selalunya perlu untuk memulakan berbilang permintaan serentak pada masa yang sama dan menggabungkan hasil permintaan ini. Pakej konteks dalam bahasa Go menyediakan cara yang elegan untuk mengurus permintaan serentak dalam senario sedemikian dan memastikan permintaan yang tidak sah boleh ditamatkan seawal mungkin apabila permintaan itu perlu dibatalkan.

Artikel ini akan memperkenalkan cara menggunakan konteks untuk menggabungkan hasil permintaan dan memberikan contoh kod yang berkaitan.

Pertama, mari kita memahami beberapa konsep utama dan kaedah penggunaan dalam pakej konteks.

1. Konteks: konteks ialah objek konteks yang boleh digunakan untuk mengawal goroutine. Dalam permintaan serentak, kita boleh menghantar objek konteks kepada setiap permintaan dan menggunakan objek konteks untuk mengurus dan mengawal permintaan ini.
2. WithCancel: Gunakan fungsi WithCancel(parent) untuk mencipta konteks anak baharu dan mengembalikan fungsi batal. Apabila kita ingin membatalkan konteks, kita hanya perlu memanggil fungsi batal.
3. WithTimeout: Gunakan fungsi WithTimeout(parent, timeout) untuk mencipta konteks dengan timeout. Selepas masa yang ditentukan, konteks akan dibatalkan secara automatik.

Selepas memahami konsep asas ini, kita boleh mula melaksanakan penggabungan hasil permintaan.

Mula-mula, mari kita anggap kita mempunyai perkhidmatan yang perlu membuat permintaan kepada berbilang API luaran secara serentak dan menggabungkan hasilnya. Kita boleh menggunakan konteks untuk mencapai fungsi berikut:

1. Buat konteks ibu bapa dan cipta konteks kanak-kanak untuk setiap permintaan.
2. Dalam setiap goroutine, gunakan subkonteks ini untuk menghantar permintaan dan tunggu hasilnya.
3. Apabila semua permintaan selesai, kembalikan hasilnya melalui saluran atau cara lain.

Seterusnya, mari lihat kod sampel yang menggunakan konteks untuk melaksanakan penggabungan hasil permintaan:

package main

import (
    "context"
    "fmt"
    "net/http"
    "sync"
    "time"
)

func fetchData(ctx context.Context, url string, wg *sync.WaitGroup, ch chan<- string) {
    defer wg.Done()

    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        ch <- fmt.Sprintf("%s failed: %v", url, err)
        return
    }

    select {
    case <-ctx.Done():
        ch <- fmt.Sprintf("%s cancelled", url)
        return
    default:
    }

    client := http.DefaultClient
    resp, err := client.Do(req)
    if err != nil {
        ch <- fmt.Sprintf("%s failed: %v", url, err)
        return
    }

    select {
    case <-ctx.Done():
        ch <- fmt.Sprintf("%s cancelled", url)
    case <-time.After(1 * time.Second):
        body := make([]byte, 1024)
        _, _ = resp.Body.Read(body)
        ch <- fmt.Sprintf("%s fetched: %s", url, body)
    }

    resp.Body.Close()
}

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

    urls := []string{"https://www.google.com", "https://www.bing.com", "https://www.baidu.com"}

    var wg sync.WaitGroup
    results := make(chan string, len(urls))

    for _, url := range urls {
        wg.Add(1)
        go fetchData(ctx, url, &wg, results)
    }

    go func() {
        wg.Wait()
        close(results)
    }()

    for res := range results {
        fmt.Println(res)
    }
}

Dalam kod contoh di atas, kita mula-mula mencipta konteks induk, dan kemudian mencipta konteks anak untuk setiap permintaan.

Dalam fungsi fetchData, kami menggunakan pernyataan pilih untuk menyemak sama ada konteks telah dibatalkan. Jika dibatalkan, permintaan akan ditamatkan serta-merta. Jika ia tidak dibatalkan, hantar permintaan dan tunggu hasilnya.

Akhir sekali, kami memulakan berbilang goroutine dalam fungsi utama untuk memproses permintaan dan mengembalikan hasilnya melalui saluran. Kami menggunakan sync.WaitGroup untuk menunggu semua permintaan selesai dan boleh membatalkan keseluruhan proses permintaan pada bila-bila masa melalui fungsi batal.

Ringkasan:

Dengan menggunakan pakej konteks, kami boleh mengurus permintaan serentak dengan anggun dan membatalkan permintaan yang tidak sah tepat pada masanya apabila diperlukan. Kod sampel di atas menunjukkan cara menggunakan konteks untuk menggabungkan hasil permintaan Dengan menggunakan konteks secara rasional, kami boleh meningkatkan keupayaan pemprosesan serentak sistem sambil mengekalkan kejelasan dan kebolehbacaan kod.

Kunci untuk menggunakan konteks ialah menggunakan fungsi dengan betul seperti WithCancel dan WithTimeout untuk mencipta subkonteks dan gunakan penyataan pilih dalam goroutine untuk menyemak sama ada untuk membatalkan atau tamat masa. Dengan cara ini, kami boleh menamatkan permintaan tidak sah tepat pada masanya apabila diperlukan dan menggabungkan hasil permintaan yang sah.

Dengan memahami secara mendalam dan menggunakan pakej konteks secara fleksibel, kami boleh membina sistem pengedaran serentak dan boleh dipercayai dengan lebih baik.

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