Comment Go WebSocket gère-t-il les connexions simultanées ?

L'approche de Go WebSocket pour gérer les connexions simultanées : utilisez une Goroutine pour chaque connexion. Connectez la communication via Channel. Utilisez des bibliothèques tierces telles que [gowebsocket](https://github.com/gobwas/ws), [gorilla/websocket](https://github.com/gorilla/websocket) pour simplifier le traitement.

Comment Go WebSocket gère les connexions simultanées

WebSocket est un protocole de communication full-duplex qui permet une communication bidirectionnelle en temps réel entre les clients et les serveurs. Les méthodes courantes pour gérer les connexions simultanées WebSocket dans Go sont les suivantes :

1 Goroutine

Une solution simple consiste à utiliser un Goroutine pour chaque connexion. Goroutine est un thread léger dans Go qui peut s'exécuter en parallèle. Lorsqu'une nouvelle connexion WebSocket est établie, nous pouvons créer un nouveau Goroutine pour la gérer :

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 Channel

Channel est un canal concurrent utilisé pour la communication dans Go. Nous pouvons gérer plusieurs connexions via un canal :

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

Passer des connexions via des tuyaux peut partager des connexions entre tous les Goroutines et éviter la surcharge liée à la création d'un trop grand nombre de threads.

3. Bibliothèques tierces

Il existe de nombreuses bibliothèques tierces qui peuvent simplifier le traitement simultané de WebSocket, telles que :

• [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)

Ces bibliothèques fournissent une API de haut niveau pour gérer les connexions simultanées et simplifient l'utilisation de WebSocket.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!