golang tcp tidak pernah putus

Di Golang, TCP akan memutuskan sambungan secara lalai selepas membuat sambungan Ini kerana protokol TCP itu sendiri perlu memastikan kebolehpercayaan sambungan Setelah sambungan diputuskan, sambungan baharu akan diwujudkan semula. Tetapi terdapat juga beberapa situasi di mana kami berharap sambungan TCP tidak akan diputuskan Sebagai contoh, dalam situasi konkurensi yang tinggi, penubuhan sambungan yang kerap akan memberi tekanan tambahan pada pelayan. Jadi bagaimana untuk memastikan bahawa TCP Golang tidak diputuskan?

1. TCP Keep-Alive

TCP Keep-Alive ialah mekanisme yang disediakan oleh protokol TCP untuk mengesan sama ada sambungan masih aktif. Apabila sambungan TCP tidak menghantar data untuk satu tempoh masa, mekanisme Keep-Alive akan menghantar beberapa paket pengesanan khusus kepada rakan sebaya untuk mengetahui sama ada sambungan itu masih wujud. Jika rakan sebaya tidak bertindak balas kepada paket siasatan, ia akan dianggap bahawa rakan sebaya telah terputus sambungan dan sambungan akan ditutup secara aktif. Jika rakan sebaya boleh bertindak balas kepada paket siasatan, sambungan masih wujud. Kita boleh menggunakan mekanisme TCP Keep-Alive untuk mencapai Golang TCP non-disconnection.

1.1 Dayakan TCP Keep-Alive

Untuk mendayakan TCP Keep-Alive, kita perlu menetapkan sifat soket. Golang boleh menggunakan struktur TCPConn dalam pakej bersih untuk mewakili sambungan TCP. TCPConn menyediakan banyak kaedah untuk mengendalikan sambungan TCP. Antaranya, kaedah SetKeepAlive boleh digunakan untuk menetapkan TCP Keep-Alive.

Kod sampel adalah seperti berikut:

conn, err := net.Dial("tcp", "127.0.0.1:8080")
if err != nil {
    fmt.Println("dial error:", err)
    return
}
tcpConn := conn.(*net.TCPConn)
// 设置为开启 TCP KeepAlive，默认为不开启
tcpConn.SetKeepAlive(true)

1.2 Tetapkan parameter TCP Keep-Alive

TCP Keep-Alive mempunyai tiga parameter dan kami boleh menetapkan parameter ini melalui tetapan kaedah TCPConn. Mereka ialah KeepAlive, KeepAlivePeriod dan KeepAliveCount.

• KeepAlive: Menunjukkan sama ada untuk mendayakan TCP Keep-Alive. Lalai tidak didayakan.
• KeepAlivePeriod: Menunjukkan selang masa untuk menghantar paket pengesanan. Lalai tidak ditetapkan dan ditentukan oleh sistem pengendalian.
• KeepAliveCount: Menunjukkan bilangan kali paket pengesanan dihantar. Lalai tidak ditetapkan dan ditentukan oleh sistem pengendalian.

Kita boleh tetapkan ketiga-tiga parameter ini mengikut keperluan sebenar.

Kod sampel adalah seperti berikut:

tcpConn.SetKeepAlive(true)          // 开启 TCP Keep-Alive
tcpConn.SetKeepAlivePeriod(time.Duration(30) * time.Second) // 设置探测包发送时间间隔为 30 秒
tcpConn.SetKeepAliveCount(3)        // 设置探测包的发送次数为 3

1.3 Kekerapan penghantaran paket pengesanan Keep-Alive

Secara lalai, kekerapan penghantaran paket pengesanan Keep-Alive ditentukan oleh sistem pengendalian. Dalam kebanyakan sistem pengendalian, paket probe TCP Keep-Alive dihantar setiap 2 jam Jika kekerapan perlu ditukar, ini boleh dicapai dengan menukar parameter dalam sistem pengendalian. Dalam sistem pengendalian Linux, anda boleh menukar kekerapan menghantar paket pengesanan TCP Keep-Alive dengan mengubah suai parameter dalam sistem fail proc.

2. Gunakan sambungan panjang

Cara lain untuk mencapai tidak putus sambungan Golang TCP ialah menggunakan sambungan panjang. Sambungan panjang merujuk kepada sambungan tanpa gangguan antara klien dan pelayan. Dalam mod sambungan panjang, selepas pelanggan mewujudkan sambungan dengan pelayan, pelanggan boleh menghantar permintaan pada bila-bila masa, dan pelayan juga boleh menghantar respons pada bila-bila masa. Ini boleh mengurangkan overhed yang ditanggung apabila kerap membuat sambungan dan meningkatkan prestasi pelayan.

Mengenai cara melaksanakan sambungan panjang, berikut ialah contoh kod mudah untuk rujukan.

package main

import (
    "bufio"
    "fmt"
    "net"
)

func main() {
    listen, err := net.Listen("tcp", ":8080")
    if err != nil {
        panic(err)
    }

    for {
        conn, err := listen.Accept()
        if err != nil {
            continue
        }
        go handle(conn)
    }
}

func handle(conn net.Conn) {
    defer conn.Close()

    reader := bufio.NewReader(conn)
    for {
        data, err := reader.ReadString('
')
        if err != nil {
            return
        }

        response := fmt.Sprintf("echo: %s", data)
        conn.Write([]byte(response))
    }
}

Dalam kod sampel di atas, kami memulakan perkhidmatan TCP untuk menerima permintaan pelanggan. Apabila klien mewujudkan sambungan dengan pelayan, pelayan menerima permintaan klien melalui gelung dan mengembalikan respons. Oleh kerana sambungan antara pelayan dan klien tidak akan diputuskan secara aktif, klien boleh menghantar permintaan kepada pelayan pada bila-bila masa.

3. Ringkasan

Artikel ini memperkenalkan dua kaedah untuk mencapai tidak putus sambungan TCP Golang, iaitu menggunakan mekanisme TCP Keep-Alive dan menggunakan sambungan panjang. Dalam perkembangan sebenar, anda harus memilih kaedah yang sesuai dengan anda mengikut situasi sebenar. Jika anda hanya menggunakan sambungan TCP secara ringan, adalah disyorkan untuk menggunakan TCP Keep-Alive jika anda perlu menghantar permintaan dengan kerap, adalah disyorkan untuk menggunakan sambungan yang panjang. Tidak kira kaedah yang digunakan, dalam aplikasi sebenar, perhatian perlu diberikan untuk menyeragamkan dan melindungi keselamatan sambungan untuk mengelakkan kelemahan keselamatan.

Atas ialah kandungan terperinci golang tcp tidak pernah putus. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!