WebSocket ist zu einem sehr beliebten Protokoll in der modernen Echtzeit-Webanwendungsentwicklung geworden. Beim Schreiben von Anwendungen mit WebSocket müssen wir dessen Leistungsoptimierung berücksichtigen, um sicherzustellen, dass unsere Anwendung schnell und genau auf Kundenanfragen reagieren kann. In diesem Artikel diskutieren wir, wie die Leistung von Go WebSocket-Anwendungen optimiert werden kann, und stellen konkrete Codebeispiele bereit.
- Verwenden Sie die richtige WebSocket-Bibliothek
Go Language bietet mehrere beliebte WebSocket-Bibliotheken zur Auswahl, wie Gorilla WebSocket, Gobwas WebSocket und Fasthttp WebSocket. Unter ihnen ist die Gorilla WebSocket-Bibliothek eine der am häufigsten verwendeten Bibliotheken und bietet mehr Funktionen als andere Bibliotheken. Bei der Auswahl einer WebSocket-Bibliothek sollten Sie deren Leistung, Funktionalität und Benutzerfreundlichkeit berücksichtigen.
In diesem Artikel verwenden wir zur Demonstration die Gorilla WebSocket-Bibliothek.
- Verwenden Sie WebSocket-Verbindungen angemessen
Beim Entwerfen von WebSocket-Anwendungen sollten wir unnötige Verbindungen so weit wie möglich vermeiden. Jede WebSocket-Verbindung verbraucht Serverressourcen. Wenn also ein Vorgang, der über eine Verbindung hätte abgeschlossen werden können, zu mehreren Verbindungen führt, weil die Verbindung nicht geplant ist, wird der Server überlastet. Es wird empfohlen, Verbindungen bei Bedarf herzustellen und so oft wie möglich langlebige Verbindungen zu verwenden, um den Aufwand für die Einrichtung neuer Verbindungen zu vermeiden.
Sehen wir uns einen Beispielcode zum Erstellen einer WebSocket-Verbindung mithilfe der Gorilla WebSocket-Bibliothek an:
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
}Nach dem Login kopieren
Im obigen Beispielcode haben wir eine handleWebSocket-Funktion erstellt, um die WebSocket-Verbindung zu verwalten. In dieser Funktion verwenden wir die Funktion upgrader.Upgrade(), um die HTTP-Verbindung auf eine WebSocket-Verbindung zu aktualisieren. Beachten Sie, dass hier die Funktion defer conn.Close() verwendet wird, um sicherzustellen, dass die WebSocket-Verbindung am Ende der Funktion geschlossen wird.
- WebSocket richtig konfigurieren
Wenn die Anzahl der Verbindungen ein bestimmtes Niveau erreicht, ist der Lastausgleich der WebSocket-Konfiguration sehr wichtig. Für Server verfügt WebSocket über zwei Konfigurationsparameter, die besonders wichtig sind: ReadBufferSize und WriteBufferSize. Diese beiden Parameter steuern die Größe des Lesepuffers und des Schreibpuffers der WebSocket-Verbindung. Ein zu großer Puffer kann die Verbindungsleistung beeinträchtigen, während ein zu kleiner Puffer die Anzahl zusätzlicher Datenübertragungen erhöhen kann.
Bei Verwendung der Gorilla WebSocket-Bibliothek können wir die Größe des Puffers wie folgt ändern:
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}Nach dem Login kopieren
Im obigen Beispielcode legen wir die Größe von ReadBufferSize und WriteBufferSize auf 1024 Bytes fest. Bitte stellen Sie die entsprechende Größe entsprechend dem tatsächlichen Bedarf ein.
- Verwendung der Parallelitätsverarbeitung
WebSocket-Anwendungen müssen eine große Anzahl gleichzeitiger Verbindungen unterstützen, daher müssen sie Goroutinen verwenden, um jede Verbindung zu verarbeiten. Sie können den von der Standardbibliothek der Go-Sprache bereitgestellten Goroutine-Mechanismus verwenden, um mehrere WebSocket-Verbindungen zu verarbeiten. Übergeben Sie einfach die erstellten WebSocket-Verbindungen an die Goroutinen und sie verarbeiten jede Verbindung problemlos.
Hier ist ein Beispielcode, der die gleichzeitige Verarbeitung von WebSocket-Verbindungen verwendet:
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)
}Nach dem Login kopieren
Im obigen Beispielcode verwenden wir Goroutine, um jede WebSocket-Verbindung zu verarbeiten. In jeder Goroutine empfangen wir WebSocket-Nachrichten mit der Funktion conn.ReadMessage(). Wir können dann Nachrichten in jeder Goroutine verarbeiten.
- Effiziente Speichernutzung
Bei jeder WebSocket-Verbindung verbraucht der erstellte Puffer viel Speicher. Daher müssen wir eine maximale Speicherauslastung sicherstellen. Hier ein paar Vorschläge:
- Zwischenspeichern Sie zu sendende Nachrichten und vermeiden Sie häufige Speicherbelegung beim Schreiben.
- Verwenden Sie den regulären Garbage-Collection-Mechanismus, um Speicherverluste durch nicht referenzierte Zeiger zu vermeiden.
- Vermeiden Sie das Erstellen großer Objekte oder den Aufruf von Bibliotheken oder Funktionen mit schlechter Leistung bei der WebSocket-Nachrichtenverarbeitung.
Das folgende Beispiel zeigt beispielsweise, wie Nachrichten zwischengespeichert und der Cache regelmäßig geleert werden:
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
}Nach dem Login kopieren
Im obigen Beispielcode haben wir eine Verbindungsstruktur mit zwei Feldern erstellt: conn und send. Das Sendefeld ist ein Kanal mit Puffer, in dem alle Nachrichten zwischengespeichert werden. Anschließend nutzen wir den Ticker, um regelmäßig Nachrichten zu löschen und zu versenden.
Zusammenfassung:
Um die Leistung von WebSocket-Anwendungen in der Go-Sprache zu optimieren, müssen Sie die folgenden Aspekte berücksichtigen:
- Verwenden Sie die richtige WebSocket-Bibliothek
- Verwenden Sie die WebSocket-Verbindung angemessen
- Konfigurieren Sie WebSocket angemessen
- Verwenden Sie Parallelitätsverarbeitung
- Speicher effizient nutzen
Die oben genannten sind einige der effektivsten Möglichkeiten, die Leistung von WebSocket-Anwendungen in der Go-Sprache zu optimieren. Obwohl der Beispielcode in diesem Artikel nicht umfassend ist, sollten Sie die oben genannten Empfehlungen befolgen, um die Anwendungsleistung bei der Entwicklung von WebSocket-Anwendungen zu verbessern.
Das obige ist der detaillierte Inhalt vonSo optimieren Sie die Leistung der Go-Sprach-Websocket-Anwendung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
