Bagaimanakah Go WebSocket mengendalikan sambungan serentak?

Pergi pendekatan WebSocket untuk mengendalikan sambungan serentak: Gunakan Goroutine untuk setiap sambungan. Sambungkan komunikasi melalui Saluran. Gunakan perpustakaan pihak ketiga seperti [gowebsocket](https://github.com/gobwas/ws), [gorilla/websocket](https://github.com/gorilla/websocket) untuk memudahkan pemprosesan.

How Go WebSocket mengendalikan sambungan serentak

WebSocket ialah protokol komunikasi dupleks penuh yang membenarkan komunikasi dua hala masa nyata antara pelanggan dan pelayan. Cara biasa untuk mengendalikan sambungan serentak WebSocket dalam bahasa Go adalah seperti berikut:

1 Goroutine

Penyelesaian mudah ialah menggunakan Goroutine untuk setiap sambungan. Goroutine ialah benang ringan dalam Go yang boleh dilaksanakan secara selari. Apabila sambungan WebSocket baharu diwujudkan, kami boleh mencipta Goroutine baharu untuk mengendalikannya:

package main

import (
    "fmt"
    "net/http"
    "os"

    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{}

func main() {
    // WebSocket 服务器端口号
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        // 对请求进行 WebSocket 升级
        conn, err := upgrader.Upgrade(w, r, nil)
        if err != nil {
            fmt.Println(err)
            return
        }

        // 创建一个 Goroutine 处理连接
        go handleConnection(conn)
    })

    http.ListenAndServe(":"+port, nil)
}

// handleConnection 处理一个 WebSocket 连接
func handleConnection(conn *websocket.Conn) {
    for {
        msgType, msg, err := conn.ReadMessage()
        if err != nil {
            fmt.Println(err)
            break
        }

        if msgType == websocket.TextMessage {
            // 处理文本消息
            fmt.Println("Received text message:", string(msg))
            if err := conn.WriteMessage(msgType, msg); err != nil {
                fmt.Println(err)
            }
        } else {
            // 处理其他类型的消息
        }
    }

    conn.Close()
}

2 Saluran

Saluran adalah saluran serentak yang digunakan untuk komunikasi dalam Go. Kami boleh mengendalikan berbilang sambungan melalui Saluran:

package main

import (
    "fmt"
    "net/http"
    "os"
    "sync"
    "time"

    "github.com/gorilla/websocket"
)

var (
    upgrader = websocket.Upgrader{}
    connections = make(chan *websocket.Conn, 100)
    wg sync.WaitGroup
)

func main() {
    // WebSocket 服务器端口号
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        // 对请求进行 WebSocket 升级
        conn, err := upgrader.Upgrade(w, r, nil)
        if err != nil {
            fmt.Println(err)
            return
        }

        // 将连接添加到 Channel
        connections <- conn
    })

    // 启动一个 Goroutine 处理 Channel 中的连接
    go handleConnections()

    http.ListenAndServe(":"+port, nil)
}

// handleConnections 处理 Channel 中的 WebSocket 连接
func handleConnections() {
    for {
        conn := <-connections

        wg.Add(1)
        go func() {
            defer wg.Done()
            for {
                msgType, msg, err := conn.ReadMessage()
                if err != nil {
                    fmt.Println(err)
                    break
                }

                if msgType == websocket.TextMessage {
                    // 处理文本消息
                    fmt.Println("Received text message:", string(msg))

                    // 向所有连接的客户端广播消息
                    for c := range connections {
                        if c != conn {
                            if err := c.WriteMessage(msgType, msg); err != nil {
                                fmt.Println(err)
                            }
                        }
                    }
                } else {
                    // 处理其他类型的消息
                }
            }

            conn.Close()
        }()
    }
}

Melepasi sambungan melalui paip boleh berkongsi sambungan antara semua Goroutine dan mengelakkan overhed mencipta terlalu banyak benang.

3. Perpustakaan pihak ketiga

Terdapat banyak perpustakaan pihak ketiga yang boleh memudahkan pemprosesan serentak WebSocket, seperti:

• [gowebsocket](https://github.com/gobwas/gobwas/ [gorila/websocket ](https://github.com/gorilla/websocket)
• [fasthttp/websocket](https://github.com/valyala/fasthttp/blob/master/websocket/websocket.go)
Perpustakaan ini menyediakan Ia menyediakan API peringkat tinggi untuk mengendalikan sambungan serentak dan memudahkan penggunaan WebSocket.

Atas ialah kandungan terperinci Bagaimanakah Go WebSocket mengendalikan sambungan serentak?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!