Cara mengoptimumkan prestasi aplikasi Websocket bahasa Go

WebSocket telah menjadi protokol yang sangat popular dalam pembangunan aplikasi web masa nyata moden. Apabila menulis aplikasi menggunakan WebSocket, kami perlu mempertimbangkan pengoptimuman prestasinya untuk memastikan aplikasi kami boleh bertindak balas kepada permintaan pelanggan dengan cepat dan tepat. Dalam artikel ini, kami akan membincangkan cara mengoptimumkan prestasi aplikasi Go WebSocket dan memberikan contoh kod khusus.

1. Gunakan perpustakaan WebSocket yang betul

Bahasa Go mempunyai beberapa perpustakaan WebSocket yang popular untuk dipilih, seperti Gorilla WebSocket, Gobwas WebSocket dan Fasthttp WebSocket. Antaranya, perpustakaan Gorilla WebSocket adalah salah satu perpustakaan yang paling banyak digunakan dan ia menyediakan lebih banyak ciri berbanding perpustakaan lain. Apabila memilih perpustakaan WebSocket, anda harus mempertimbangkan prestasi, fungsi dan kemudahan penggunaannya.

Dalam artikel ini, kami akan menggunakan perpustakaan Gorilla WebSocket untuk menunjukkan.

2. Gunakan sambungan WebSocket dengan sewajarnya

Apabila mereka bentuk aplikasi WebSocket, kita harus mengelakkan sambungan yang tidak perlu sebanyak mungkin. Setiap sambungan WebSocket menggunakan sumber pelayan, jadi jika operasi yang boleh diselesaikan melalui satu sambungan mengakibatkan berbilang sambungan kerana sambungan tidak dirancang, pelayan akan terlebih beban. Adalah disyorkan agar anda membuat sambungan apabila diperlukan dan menggunakan sambungan tahan lama sekerap mungkin untuk mengelakkan beban mewujudkan sambungan baharu.

Mari kita lihat contoh kod untuk membuat sambungan WebSocket menggunakan perpustakaan Gorilla WebSocket:

package main

import (
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

func main() {
    http.HandleFunc("/ws", handleWebSocket)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func handleWebSocket(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }
    defer conn.Close()

    // use the websocket connection here
}

Dalam kod sampel di atas, kami mencipta fungsi handleWebSocket untuk mengendalikan sambungan WebSocket. Dalam fungsi ini, kami menggunakan fungsi upgrader.Upgrade() untuk menaik taraf sambungan HTTP kepada sambungan WebSocket. Ambil perhatian bahawa fungsi defer conn.Close() digunakan di sini untuk memastikan sambungan WebSocket ditutup pada penghujung fungsi.

3. Konfigurasikan WebSocket dengan betul

Apabila bilangan sambungan mencapai tahap tertentu, pengimbangan beban konfigurasi WebSocket adalah sangat penting. Untuk pelayan, WebSocket mempunyai dua parameter konfigurasi yang amat penting: ReadBufferSize dan WriteBufferSize. Kedua-dua parameter ini mengawal saiz penimbal baca dan tulis bagi sambungan WebSocket. Penampan yang terlalu besar boleh menjejaskan prestasi sambungan, manakala penimbal yang terlalu kecil boleh meningkatkan bilangan pemindahan data tambahan.

Apabila menggunakan perpustakaan Gorilla WebSocket, kita boleh menukar saiz penimbal dengan:

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

Dalam kod contoh di atas, kami menetapkan saiz ReadBufferSize dan WriteBufferSize kepada 1024 bait. Sila tetapkan saiz yang sesuai mengikut keperluan sebenar.

4. Menggunakan Concurrency Processing

Aplikasi WebSocket perlu menyokong sejumlah besar sambungan serentak, jadi mereka perlu menggunakan goroutine untuk mengendalikan setiap sambungan. Anda boleh menggunakan mekanisme goroutine yang disediakan oleh perpustakaan standard bahasa Go untuk mengendalikan berbilang sambungan WebSocket. Hanya hantar sambungan WebSocket yang dibuat ke goroutine dan mereka akan mengendalikan setiap sambungan dengan mudah.

Berikut ialah kod sampel yang menggunakan pemprosesan serentak sambungan WebSocket:

func main() {
    http.HandleFunc("/ws", handleWebSocket)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func handleWebSocket(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }

    go func(conn *websocket.Conn) {
        for {
            _, message, err := conn.ReadMessage()
            if err != nil {
                log.Println(err)
                return
            }

            log.Printf("received message: %s", message)
            // handle the message here
        }
    }(conn)
}

Dalam kod sampel di atas, kami menggunakan goroutine untuk mengendalikan setiap sambungan WebSocket. Dalam setiap goroutine, kami menerima mesej WebSocket menggunakan fungsi conn.ReadMessage(). Kami kemudiannya boleh memproses mesej dalam setiap goroutine.

5. Penggunaan memori yang cekap

Dalam setiap sambungan WebSocket, penimbal yang dibuat menggunakan banyak memori. Jadi kita perlu memastikan penggunaan memori maksimum. Berikut adalah beberapa cadangan:

• Cache mesej untuk dihantar dan elakkan peruntukan memori yang kerap semasa menulis.
• Gunakan mekanisme pengumpulan sampah biasa untuk mengelakkan kebocoran memori yang disebabkan oleh penunjuk yang tidak dirujuk.
• Elakkan membuat objek besar atau memanggil perpustakaan atau fungsi berprestasi buruk dalam pemprosesan mesej WebSocket.

Sebagai contoh, contoh berikut menunjukkan cara untuk cache mesej dan bersihkan cache secara berkala:

type Connection struct {
    conn    *websocket.Conn
    send    chan []byte
}

func (c *Connection) read() {
    for {
        _, _, err := c.conn.ReadMessage()
        if err != nil {
            break
        }
    }
    c.conn.Close()
}

func (c *Connection) write() {
    ticker := time.NewTicker(10 * time.Second)
    defer func() {
        ticker.Stop()
        c.conn.Close()
    }()

    var messages [][]byte
    for {
        select {
        case message, ok := <-c.send:
            if !ok {
                c.conn.WriteMessage(websocket.CloseMessage, []byte{})
                return
            }
            messages = append(messages, message)

        case <-ticker.C:
            if err := c.conn.WriteMessage(websocket.TextMessage, bytes.Join(messages, []byte{})); err != nil {
                return
            }
            messages = nil
        }
    }
}

func main() {
    http.HandleFunc("/ws", handleWebSocket)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func handleWebSocket(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }
    connection := &Connection{conn: conn, send: make(chan []byte, 256)}
    go connection.write()
    go connection.read()

    // use the connection here
}

Dalam kod contoh di atas, kami mencipta struktur Sambungan dengan dua medan: sambung dan hantar. Medan hantar ialah saluran dengan penimbal di mana semua mesej ditimbal. Kami kemudian menggunakan penanda untuk mengosongkan dan menghantar mesej secara berkala.

Ringkasan:

Untuk mengoptimumkan prestasi aplikasi WebSocket dalam bahasa Go, anda perlu mempertimbangkan aspek berikut:

• Gunakan perpustakaan WebSocket yang betul
• Gunakan sambungan WebSocket dengan munasabah
• Konfigurasi pemprosesan WebSocket dengan munasabah
Gunakan Memori dengan cekap

Atas ialah kandungan terperinci Cara mengoptimumkan prestasi aplikasi Websocket bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!