golang http sambungan rapat

Apabila menggunakan Golang untuk pengaturcaraan HTTP, kita perlu sering mempertimbangkan cara untuk menutup sambungan. Menutup sambungan dengan berkesan boleh mengelakkan pembaziran sumber, meningkatkan prestasi dan mengurangkan masalah yang tidak perlu yang disebabkan oleh masalah rangkaian. Artikel ini akan memperkenalkan secara terperinci cara menutup sambungan HTTP di Golang dan menganalisis beberapa butiran.

1. Cara menutup sambungan HTTP

Klien dan pelayan HTTP dalam bahasa Go melaksanakan satu siri proses asas untuk mengurus sambungan HTTP. Pemprosesan peringkat rendah ini biasanya tidak didedahkan kepada pengguna, tetapi tersembunyi dalam pelaksanaan dalaman oleh klien dan pelayan HTTP. Jadi bagaimana untuk menutup sambungan dalam klien dan pelayan HTTP?

1. Klien HTTP

Dalam klien HTTP, kami mempunyai beberapa cara untuk menutup sambungan:

• Gunakan kata kunci tangguh untuk menutup secara manual sambungan: Selepas pelanggan memanggil antara muka, sambungan biasanya akan ditutup secara automatik. Walau bagaimanapun, jika pelanggan semasa perlu meminta antara muka beberapa kali, anda boleh mempertimbangkan untuk mengawal penutupan sambungan secara manual dan menggunakan penangguhan untuk menangguhkan penutupan sambungan Kod adalah seperti berikut:

package main
import (
    "net/http"
    "io/ioutil"
    "fmt"
    "log"
)
func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "http://www.baidu.com", nil)
    if err != nil {
        log.Fatal(err)
    }
    defer client.CloseIdleConnections() // 当函数返回时释放连接
    resp, err := client.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close() // 当函数返回时关闭body
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(string(body)[:50])
}

• . Gunakan MaxIdleConns atau MaxIdleConnsPerHost kelas Transport untuk mengawal sambungan Had atas sambungan dalam kumpulan: Bahasa http.Transport of Go mengandungi kumpulan sambungan lalai untuk mengurus sambungan HTTP. Kita boleh menggunakan dua parameter MaxIdleConns dan MaxIdleConnsPerHost untuk menentukan bilangan maksimum sambungan melahu dan bilangan maksimum sambungan hos melahu. Apabila nombor terbiar ini dicapai, Pengangkutan akan menutup lebihan sambungan secara automatik. Kodnya adalah seperti berikut:

package main
import (
    "net/http"
    "io/ioutil"
    "fmt"
    "log"
)
func main() {
    transport := &http.Transport{
        MaxIdleConns:          10, // 最大空闲连接数
        MaxIdleConnsPerHost:   3,  // 每个域名地址最大空闲连接数
    }
    client := &http.Client{Transport: transport}
    req, err := http.NewRequest("GET", "http://www.baidu.com", nil)
    if err != nil {
        log.Fatal(err)
    }
    resp, err := client.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(string(body)[:50])
}

2. Pelayan HTTP

Dalam pelayan HTTP, pengurusan sambungan biasanya diuruskan secara automatik oleh pelayan. Kami hanya perlu mencipta pelayan dan menutupnya apabila sambungan tidak lagi diperlukan. Biasanya, pelayan secara automatik menutup sambungan selepas memproses permintaan. Walau bagaimanapun, terdapat beberapa situasi khas yang memerlukan kami mengawal penutupan sambungan secara manual:

• Gunakan conn.Close() dalam pemproses HTTP untuk menutup sambungan: Apabila pemproses memproses permintaan HTTP , jika Jika pelayan perlu menutup sambungan, ia boleh menggunakan kaedah conn.Close() untuk menutup sambungan. Kodnya adalah seperti berikut:

package main
import (
    "fmt"
    "net/http"
)
func handler(w http.ResponseWriter, req *http.Request) {
    // 需要关闭连接时，使用conn.Close()
    conn, _, _ := w.(http.Hijacker).Hijack()
    conn.Close()
}
func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

• Menggunakan Keep-Alive: Apabila menggunakan Keep-Alive, kitaran hayat sambungan diuruskan oleh pelayan. Pelayan boleh menentukan masa kekal hidup untuk mengawal berapa lama sambungan harus ditutup selepas melahu. Masa ini biasanya ditetapkan dalam pengepala HTTP. Kodnya adalah seperti berikut:

package main
import (
    "log"
    "net/http"
)
func handler(w http.ResponseWriter, req *http.Request) {
    w.Header().Set("Connection", "keep-alive") // 定义keep-alive时间
    w.Write([]byte("hello world"))
}
func main() {
    http.HandleFunc("/", handler)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

2 mekanisme kitar semula sambungan HTTP

Apabila sambungan habis, kita perlu mengitar semula sumber untuk sambungan untuk mengelakkan kebocoran sumber, penurunan prestasi. dan masalah lain. Mekanisme kitar semula sumber sambungan HTTP biasanya perlu mempertimbangkan isu berikut:

• Masa kewujudan maksimum sambungan lama HTTP: Selepas sambungan melahu untuk satu tempoh masa, pelayan akan mengitar semula sambungan dengan serta-merta . Masa ini boleh ditentukan oleh pelayan Hanya tetapkan tamat masa sambungan semasa membuat objek pelayan.
• Bilangan maksimum sambungan HTTP: Bilangan maksimum sambungan yang dibenarkan dalam kumpulan sambungan dalam tempoh masa. Apabila kolam sambungan melebihi saiz kolam sambungan, ia akan ditutup secara automatik.
• Mekanisme penggunaan semula sambungan HTTP: Penggunaan semula sambungan bermaksud berbilang permintaan berkongsi sambungan pada masa yang sama. Ini boleh mengurangkan penggunaan sumber yang tidak perlu semasa keadaan menunggu yang lama. Walau bagaimanapun, perlu diingat bahawa jika tamat masa sambungan adalah singkat, ia boleh menyebabkan permintaan dengan turun naik rangkaian sementara gagal, sekali gus menjejaskan kestabilan sistem.

3. Pengurusan kumpulan sambungan HTTP

Dalam sistem konkurensi tinggi berskala besar, kami perlu menggunakan kumpulan sambungan untuk mengurus sambungan HTTP untuk meningkatkan prestasi dan kestabilan sistem. Apabila membuat permintaan HTTP, kumpulan sambungan boleh menyediakan sambungan rangkaian terbiar untuk mengelakkan overhed kerap mencipta dan memusnahkan sambungan. Kumpulan sambungan biasanya diurus menggunakan baris gilir biasa untuk memastikan elemen yang memasuki baris gilir digunakan dahulu, iaitu baris gilir FIFO. Berikut ialah kod untuk melaksanakan kumpulan sambungan HTTP menggunakan bahasa Go:

package main
import (
    "fmt"
    "log"
    "net/http"
    "sync"
    "time"
)
type MyHttpClient struct {
    client    *http.Client     // http客户端对象
    Transport *http.Transport  // transport对象，用于管理http连接池
}
var once sync.Once
var myClient *MyHttpClient
func GetMyHttpClient() *MyHttpClient {
    once.Do(func() {
        myClient = &MyHttpClient{
            Transport: &http.Transport{
                Dial: func(network, addr string) (net.Conn, error) {
                    conn, err := net.DialTimeout(network, addr, 10*time.Second)
                    if err != nil {
                        return nil, err
                    }
                    return conn, nil
                },
                MaxIdleConns:          100,               // 连接池中最多拥有的连接数
                MaxIdleConnsPerHost:   2,                 // 每个域名最多拥有的连接数
                IdleConnTimeout:       60 * time.Second,  // 连接在闲置多久后被关闭
                TLSHandshakeTimeout:   10 * time.Second,  // TLS握手时限
                ExpectContinueTimeout: 1 * time.Second,   // 100-continue超时时限
            },
            client: &http.Client{},
        }
    })
    return myClient
}
func main() {
    client := GetMyHttpClient().client
    req, err := http.NewRequest("GET", "http://www.baidu.com", nil)
    if err != nil {
        log.Fatal(err)
    }
    defer client.CloseIdleConnections()
    resp, err := client.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(string(body)[:50])
}

4. Ringkasan

Kawalan dan kitar semula sambungan HTTP ialah titik pengoptimuman prestasi utama. Di Golang, kami boleh mengurus sambungan HTTP melalui kawalan manual, tetapan parameter menggunakan kelas Pengangkutan dan pengumpulan sambungan untuk meningkatkan prestasi dan kestabilan sistem. Di samping itu, kami juga perlu mempertimbangkan isu seperti mekanisme kitar semula sambungan dan pengurusan kolam sambungan HTTP, dan menyelenggara dan mengoptimumkan sistem.

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