Golang Websocket包测试指南

从你提供的基准测试结果来看，gws 的性能表现确实非常出色，在相同测试条件下显著优于其他主流 WebSocket 库。这主要得益于其高效的内存管理和并发处理设计。以下是一些关键的技术分析和测试建议：

性能优势分析

gws 的高性能主要来自这几个设计：

1. 零拷贝技术：减少内存分配和复制开销
2. 事件驱动架构：基于 epoll/kqueue 的高效 I/O 多路复用
3. 内存池优化：重用缓冲区减少 GC 压力

完整的基准测试示例

这里提供一个更全面的性能测试示例，包含连接处理和消息吞吐：

package main

import (
    "log"
    "net/http"
    "time"
    "github.com/lxzan/gws"
)

// 简单的 Echo 服务器
func main() {
    upgrader := gws.NewUpgrader(&Handler{}, &gws.ServerOption{
        ReadAsyncEnabled: true, // 启用异步读取
        CompressEnabled:  true, // 启用压缩
    })
    
    http.HandleFunc("/connect", func(w http.ResponseWriter, r *http.Request) {
        socket, err := upgrader.Upgrade(w, r)
        if err != nil {
            return
        }
        socket.ReadLoop() // 开始读取循环
    })
    
    log.Fatal(http.ListenAndServe(":8000", nil))
}

type Handler struct{}

func (c *Handler) OnOpen(socket *gws.Conn) {
    log.Printf("连接建立: %s", socket.RemoteAddr())
}

func (c *Handler) OnClose(socket *gws.Conn, err error) {
    log.Printf("连接关闭: %v", err)
}

func (c *Handler) OnPing(socket *gws.Conn, payload []byte) {
    socket.WritePong(payload)
}

func (c *Handler) OnPong(socket *gws.Conn, payload []byte) {}

func (c *Handler) OnMessage(socket *gws.Conn, message *gws.Message) {
    defer message.Close()
    
    // Echo 消息回客户端
    socket.WriteMessage(message.Opcode, message.Bytes())
}

压力测试脚本

创建一个自动化测试脚本，模拟真实场景：

package test

import (
    "testing"
    "time"
    "github.com/gorilla/websocket"
    "github.com/lxzan/gws"
)

// 连接压力测试
func BenchmarkGWSConnections(b *testing.B) {
    // 启动服务器
    go startGWSServer()
    time.Sleep(100 * time.Millisecond)
    
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        // 建立连接
        conn, _, err := websocket.DefaultDialer.Dial("ws://localhost:8000/connect", nil)
        if err != nil {
            b.Fatal(err)
        }
        
        // 发送测试消息
        msg := make([]byte, 1024)
        conn.WriteMessage(websocket.BinaryMessage, msg)
        
        // 接收响应
        _, _, err = conn.ReadMessage()
        if err != nil {
            b.Fatal(err)
        }
        
        conn.Close()
    }
}

// 消息吞吐测试
func BenchmarkGWSThroughput(b *testing.B) {
    conn, _, _ := websocket.DefaultDialer.Dial("ws://localhost:8000/connect", nil)
    defer conn.Close()
    
    msg := make([]byte, 1024)
    b.ResetTimer()
    
    for i := 0; i < b.N; i++ {
        conn.WriteMessage(websocket.BinaryMessage, msg)
        _, _, err := conn.ReadMessage()
        if err != nil {
            b.Fatal(err)
        }
    }
}

func startGWSServer() {
    upgrader := gws.NewUpgrader(&gwsHandler{}, &gws.ServerOption{})
    http.HandleFunc("/connect", func(w http.ResponseWriter, r *http.Request) {
        socket, _ := upgrader.Upgrade(w, r)
        socket.ReadLoop()
    })
    http.ListenAndServe(":8000", nil)
}

type gwsHandler struct{}

func (h *gwsHandler) OnOpen(c *gws.Conn) {}
func (h *gwsHandler) OnClose(c *gws.Conn, err error) {}
func (h *gwsHandler) OnPing(c *gws.Conn, payload []byte) { c.WritePong(payload) }
func (h *gwsHandler) OnPong(c *gws.Conn, payload []byte) {}
func (h *gwsHandler) OnMessage(c *gws.Conn, message *gws.Message) {
    c.WriteMessage(message.Opcode, message.Bytes())
    message.Close()
}

内存使用监控

添加内存分析来验证 GC 效率：

func TestGWSMemoryUsage(t *testing.T) {
    var m1, m2 runtime.MemStats
    
    runtime.ReadMemStats(&m1)
    
    // 创建大量连接
    var conns []*gws.Conn
    for i := 0; i < 10000; i++ {
        // 模拟连接创建
    }
    
    runtime.GC()
    runtime.ReadMemStats(&m2)
    
    allocated := m2.TotalAlloc - m1.TotalAlloc
    t.Logf("内存分配: %.2f MB", float64(allocated)/1024/1024)
}

你的测试结果已经充分展示了 gws 的性能优势。通过上述更全面的测试方案，可以进一步验证库在不同场景下的稳定性。特别是在高并发连接和消息吞吐方面，gws 的设计确实带来了显著的性能提升。