Wie geht Go WebSocket mit gleichzeitigen Verbindungen um?

Go WebSockets Ansatz zur Handhabung gleichzeitiger Verbindungen: Verwenden Sie für jede Verbindung eine Goroutine. Verbinden Sie die Kommunikation über den Kanal. Verwenden Sie Bibliotheken von Drittanbietern wie [gowebsocket](https://github.com/gobwas/ws), [gorilla/websocket](https://github.com/gorilla/websocket), um die Verarbeitung zu vereinfachen.

So verarbeitet WebSocket gleichzeitige Verbindungen

WebSocket ist ein Vollduplex-Kommunikationsprotokoll, das eine bidirektionale Echtzeitkommunikation zwischen Clients und Servern ermöglicht. Die gängigen Methoden zum Umgang mit gleichzeitigen WebSocket-Verbindungen in der Go-Sprache sind wie folgt:

1. Goroutine

Eine einfache Lösung besteht darin, für jede Verbindung eine Goroutine zu verwenden. Goroutine ist ein leichter Thread in Go, der parallel ausgeführt werden kann. Wenn eine neue WebSocket-Verbindung hergestellt wird, können wir eine neue Goroutine erstellen, um diese zu verarbeiten:

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 Kanal

Kanal ist ein gleichzeitiger Kanal, der für die Kommunikation in Go verwendet wird. Wir können mehrere Verbindungen über einen Kanal verwalten:

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()
        }()
    }
}

Durch die Weiterleitung von Verbindungen über Pipes können Verbindungen zwischen allen Goroutinen gemeinsam genutzt werden und der Aufwand durch die Erstellung zu vieler Threads vermieden werden.

3. Bibliotheken von Drittanbietern

Es gibt viele Bibliotheken von Drittanbietern, die die gleichzeitige Verarbeitung von WebSockets vereinfachen können, wie zum Beispiel:

• [gowebsocket](https://github.com/gobwas/ws)
• [gorilla/websocket](https://github.com/gorilla/websocket)
• [fasthttp/websocket](https://github.com/valyala/fasthttp/blob/master/websocket/websocket.go)

Diese Bibliotheken stellen eine High-Level-API für die Verarbeitung gleichzeitiger Verbindungen bereit und vereinfachen die Verwendung von WebSocket.

Das obige ist der detaillierte Inhalt vonWie geht Go WebSocket mit gleichzeitigen Verbindungen um?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!