http.Kemahiran pengoptimuman pengangkutan dan perkongsian amalan dalam bahasa Go

Perkongsian http.Petua dan amalan pengoptimuman pengangkutan dalam bahasa Go

Pengenalan:
Dalam bahasa Go, menggunakan http.Transport untuk membuat permintaan rangkaian adalah operasi yang sangat biasa. Walau bagaimanapun, dalam permintaan serentak berskala besar, penggunaan http.Transport yang tidak munasabah boleh menyebabkan kesesakan prestasi dalam permintaan rangkaian dengan mudah. Artikel ini akan meneroka beberapa teknik dan amalan pengoptimuman untuk membantu pembangun meningkatkan prestasi permintaan rangkaian dengan lebih baik.

1. Gunakan kumpulan sambungan
Secara lalai, http.Transport akan membuat sambungan serentak untuk setiap permintaan HTTP. Kelebihan ini ialah ia boleh menggunakan sepenuhnya keupayaan pemprosesan serentak pelayan, tetapi ia juga akan menyebabkan beberapa masalah. Pertama, membuat dan menutup sambungan dengan kerap boleh menyebabkan overhed prestasi yang tidak perlu. Kedua, pelayan mungkin mempunyai had pada bilangan sambungan, dan terlalu banyak permintaan serentak boleh menyebabkan penafian perkhidmatan pada pelayan. Oleh itu, menggunakan pengumpulan sambungan boleh mengelakkan masalah ini dengan berkesan.

Sampel kod:

package main

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

var client *http.Client

func init() {
    transport := &http.Transport{
        MaxIdleConns:        100,               // 最大空闲连接数
        IdleConnTimeout:     90 * time.Second,  // 空闲连接的超时时间
        TLSHandshakeTimeout: 10 * time.Second,  // TLS握手的超时时间
        ExpectContinueTimeout: 1 * time.Second, // 100-continue状态响应的超时时间
    }
    client = &http.Client{
        Transport: transport,
        Timeout:   10 * time.Second, // 完整请求的超时时间
    }
}

func main() {
    resp, err := client.Get("https://www.example.com")
    if err != nil {
        fmt.Println("请求错误：", err)
        return
    }
    defer resp.Body.Close()

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

2. Dayakan Keep-Alive

Keep-Alive ialah mekanisme untuk sambungan berterusan HTTP, yang membolehkan pelanggan dan pelayan menghantar berbilang permintaan dan respons HTTP pada sambungan TCP yang sama. Mendayakan Keep-Alive boleh mengurangkan kos penubuhan sambungan dan meningkatkan prestasi permintaan rangkaian.

Dalam http.Transport, Keep-Alive didayakan secara lalai. Walau bagaimanapun, jika pelayan tidak menyokong Keep-Alive, sambungan masih akan dibuat dan ditutup dengan kerap. Oleh itu, kami boleh mengawal bilangan maksimum sambungan melahu bagi setiap hos dengan menetapkan sifat MaxIdleConnsPerHost http.Transport, dengan itu mengurangkan kekerapan pembuatan dan penutupan sambungan.

Contoh kod:

package main

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

var client *http.Client

func init() {
    transport := &http.Transport{
        MaxIdleConns:        100,               // 最大空闲连接数
        MaxIdleConnsPerHost: 10,                // 每个host的最大空闲连接数
        IdleConnTimeout:     90 * time.Second,  // 空闲连接的超时时间
        TLSHandshakeTimeout: 10 * time.Second,  // TLS握手的超时时间
        ExpectContinueTimeout: 1 * time.Second, // 100-continue状态响应的超时时间
    }
    client = &http.Client{
        Transport: transport,
        Timeout:   10 * time.Second, // 完整请求的超时时间
    }
}

func main() {
    resp, err := client.Get("https://www.example.com")
    if err != nil {
        fmt.Println("请求错误：", err)
        return
    }
    defer resp.Body.Close()

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

3 Dayakan penggunaan semula sambungan

Dalam sesetengah senario di mana permintaan perlu dihantar dengan kerap, mendayakan penggunaan semula sambungan boleh mengoptimumkan lagi prestasi. Penggunaan semula sambungan merujuk kepada memastikan sambungan TCP terbuka selepas menghantar permintaan supaya sambungan boleh terus digunakan pada permintaan seterusnya.

Contoh kod:

package main

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

var client *http.Client

func init() {
    transport := &http.Transport{
        MaxIdleConns:        100,                // 最大空闲连接数
        MaxIdleConnsPerHost: 10,                 // 每个host的最大空闲连接数
        IdleConnTimeout:     90 * time.Second,   // 空闲连接的超时时间
        TLSHandshakeTimeout: 10 * time.Second,   // TLS握手的超时时间
        ExpectContinueTimeout: 1 * time.Second,  // 100-continue状态响应的超时时间
        DisableKeepAlives:   false,              // 启用连接复用
    }
    client = &http.Client{
        Transport: transport,
        Timeout:   10 * time.Second,  // 完整请求的超时时间
    }
}

func main() {
    resp, err := client.Get("https://www.example.com")
    if err != nil {
        fmt.Println("请求错误：", err)
        return
    }
    defer resp.Body.Close()

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

Kesimpulan:
Dengan menggunakan pengumpulan sambungan, mendayakan Keep-Alive dan penggunaan semula sambungan, kami boleh meningkatkan prestasi permintaan rangkaian dengan berkesan menggunakan bahasa http.Transport dalam Go. Sudah tentu, pengoptimuman dan pelarasan selanjutnya mungkin diperlukan untuk senario dan keperluan perniagaan yang berbeza. Saya harap artikel ini dapat membantu pembangun.

Atas ialah kandungan terperinci http.Kemahiran pengoptimuman pengangkutan dan perkongsian amalan dalam bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!