Selaras permintaan rangkaian Golang

Dengan perkembangan Internet, permintaan rangkaian merupakan pautan yang sangat penting, dan banyak aplikasi perlu mendapatkan data melalui permintaan rangkaian. Untuk senario konkurensi tinggi, konkurensi permintaan rangkaian amat penting. Artikel ini akan memperkenalkan cara menggunakan Golang untuk pemprosesan serentak permintaan rangkaian.

1. Model konkurensi Golang

Golang ialah bahasa yang menyokong pengaturcaraan serentak dan model konkurensinya adalah berdasarkan goroutine dan saluran.

Goroutine ialah benang ringan yang boleh menjalankan berbilang goroutin serentak dalam satu proses. Dalam golang, anda boleh membuat goroutine dengan mudah melalui kata kunci go, contohnya:

func test() {
    fmt.Println("hello, world!")
}

func main() {
    go test() // 创建一个goroutine
    fmt.Println("main")
}

Dalam kod di atas, fungsi ujian dicipta menjadi goroutine dan berjalan serentak apabila fungsi utama dilaksanakan.

Saluran ialah mekanisme komunikasi yang boleh digunakan untuk menghantar data antara goroutine. Penciptaan dan penggunaan saluran adalah sangat mudah, contohnya:

ch := make(chan int)
go func() {
    ch <- 1 // 发送数据到通道
}()

x := <-ch // 从通道中读取数据

Dalam kod ini, kami mencipta saluran integer ch, dan menggunakan fungsi tanpa nama untuk menghantar integer 1 ke saluran ch dalam goroutine lain. Kemudian, integer dibaca dari saluran ch dalam goroutine utama.

2. Permintaan rangkaian Golang bersamaan

Dalam golang, pakej net/http dalam perpustakaan standard menyediakan sokongan untuk protokol http. Kami boleh menggunakan pakej ini untuk memulakan permintaan http dengan mudah, sebagai contoh:

resp, err := http.Get("http://www.google.com")

Kod ini boleh memulakan permintaan http GET kepada Google dan mendapatkan respons. Walau bagaimanapun, jika anda perlu memulakan permintaan untuk berbilang URL pada masa yang sama, setiap permintaan perlu menunggu untuk permintaan sebelumnya selesai sebelum ia boleh dimulakan, yang tidak cekap.

Dalam kes ini, kita boleh menggunakan goroutin dan saluran untuk pemprosesan serentak. Contohnya:

func main() {
    urls := []string{"http://www.google.com", "http://www.sina.com.cn", "http://www.baidu.com"}

    ch := make(chan string)
    for _, url := range urls {
        go func(u string) {
            resp, err := http.Get(u)
            if err != nil {
                ch <- fmt.Sprintf("error: %s", err)
                return
            }
            defer resp.Body.Close()

            ch <- fmt.Sprintf("url: %s, status: %s", u, resp.Status)
        }(url)
    }

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

Dalam kod di atas, kami mencipta saluran jenis rentetan ch untuk menerima maklumat tentang setiap hasil permintaan. Kami menggunakan gelung for untuk mengulangi senarai URL dan menggunakan goroutine untuk membuat permintaan http GET kepada setiap URL secara individu.

Dalam goroutine, kami mula-mula memulakan permintaan dan menutup badan respons selepas permintaan selesai. Kemudian gunakan saluran ch untuk menghantar maklumat hasil yang diminta. Gelung luar untuk bertanggungjawab untuk menerima maklumat hasil yang dikembalikan oleh saluran dan mencetaknya ke konsol.

Dengan menggunakan goroutine dan saluran, kami boleh memulakan berbilang permintaan rangkaian pada masa yang sama untuk meningkatkan prestasi serentak.

3. Pemprosesan permintaan rangkaian Golang

Apabila membuat permintaan rangkaian serentak, dalam menghadapi keabnormalan rangkaian atau masa tindak balas pelayan yang panjang, kita perlu menggunakan mekanisme tamat masa untuk mengawal julat masa permintaan.

Dalam golang, kita boleh menggunakan pakej konteks untuk menambah mekanisme tamat masa, contohnya:

func main() {
    urls := []string{"http://www.google.com", "http://www.sina.com.cn", "http://www.baidu.com"}

    ch := make(chan string)
    ctx, cancel := context.WithTimeout(context.Background(), time.Second*2)
    defer cancel()
    
    for _, url := range urls {
        go func(ctx context.Context, u string) {
            req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, nil)
            if err != nil {
                ch <- fmt.Sprintf("error: %s", err)
                return
            }
            
            resp, err := http.DefaultClient.Do(req)
            if err != nil {
                ch <- fmt.Sprintf("error: %s", err)
                return
            }
            defer resp.Body.Close()

            ch <- fmt.Sprintf("url: %s, status: %s", u, resp.Status)
        }(ctx, url)
    }

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

Dalam kod di atas, kita menggunakan fungsi WithTimeout pakej konteks untuk membuat tamat masa 2 saat. Kemudian, dalam goroutine, permintaan http dengan konteks dibuat menggunakan fungsi http.NewRequestWithContext dan permintaan dihantar. Semasa proses permintaan, kami menggunakan saluran ctx.Done() untuk mendengar isyarat tamat masa Jika isyarat tamat masa dicetuskan, operasi yang diminta akan terganggu.

Dengan menggunakan mekanisme tamat masa pakej konteks, kami boleh mengawal masa permintaan rangkaian dan mengendalikan pengecualian yang mungkin berlaku semasa proses permintaan.

4. Ringkasan

Dalam artikel ini, kami memperkenalkan model konkurensi Golang, cara menggunakan goroutine dan saluran untuk pemprosesan serentak permintaan rangkaian, dan cara menggunakan pakej konteks untuk mengendalikan mekanisme tamat masa permintaan rangkaian.

Sebagai operasi biasa dalam aplikasi Internet, permintaan rangkaian mempunyai kesan yang penting dalam meningkatkan prestasi sistem. Dengan memproses permintaan rangkaian secara serentak dan menggunakan mekanisme tamat masa, kami boleh meningkatkan prestasi serentak dan kestabilan aplikasi serta menambah baik pengalaman pengguna.

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