Go netpoll 与 WebSocket 长连接通识

Go netpoll 与 WebSocket 长连接通识

Hello,我是小兔大白糖。 读完能把事件驱动网络与长连接会话管理分开讲,并意识到背压与心跳合同。

netpoll管事件驱动 I/O;WebSocket 长连接还要另写会话、心跳与背压合同。

估计阅读时间:12 分钟

netpoll 与 WebSocket 长连接
netpoll 与 WebSocket 长连接 · 点击查看 SVG 原图

1. 这是什么?概念怎么定义

1.1 Hertz 网络模型

Hertz 是字节跳动开源的高性能 HTTP 框架,核心特性:

特性说明Java 对应
netpoll基于 epoll/kqueue 的 I/O 多路复用NIO Selector
goroutine per connection每个连接一个 goroutine线程池
bitmask event事件触发机制SelectionKey

1.2 netpoll 工作原理

┌─────────────────────────────────────────────────────────────┐
│                      netpoll (epoll/kqueue)                   │
│  ┌──────────────────────────────────────────────────────┐   │
│  │                    Event Loop                         │   │
│  │  - 监听 fd 可读/可写事件                               │   │
│  │  - 事件触发时调度对应 handler                          │   │
│  │  - 高效处理海量连接                                    │   │
│  └──────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    Connection Pool                           │
│  - 管理 TCP 连接生命周期                                      │
│  - 复用连接减少建连开销                                       │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│                    Goroutine Pool                            │
│  - 请求处理goroutine复用                                     │
│  - 控制并发数量                                              │
└─────────────────────────────────────────────────────────────┘

2. 语法详解

2.1 Hertz Server 配置

import (
    "github.com/cloudwego/hertz/pkg/app"
    "github.com/cloudwego/hertz/pkg/app/server"
)
 
func main() {
    h := server.New(
        server.WithHostPorts(":8080"),
        server.WithMaxRequestBodySize(4 * 1024 * 1024),
        server.WithExitWaitTime(5 * time.Second),
    )
 
    h.GET("/health", func(c context.Context, ctx *app.RequestContext) {
        ctx.JSON(200, map[string]string{"status": "ok"})
    })
 
    h.Spin()
}

2.2 超时控制

// 读写超时配置
h := server.New(
    server.WithHostPorts(":8080"),
    // 读写超时设置为 3 秒
    server.WithReadTimeout(3 * time.Second),
    server.WithWriteTimeout(3 * time.Second),
    // 最大连接空闲时间
    server.WithIdleTimeout(30 * time.Second),
)

3. 项目代码示例

3.1 WebSocket 处理器

项目中 WebSocket 实现(internal/api/handler/websocket/websocket.go):

package websocket
 
import (
    "context"
    "sync"
    "time"
 
    "github.com/gorilla/websocket"
    "github.com/cloudwego/hertz/pkg/common/hlog"
)
 
const (
    // 写超时
    writeTimeout = 15 * time.Second
    // 读超时(ping/pong 间隔)
    readTimeout = 60 * time.Second
    // 最大消息大小
    maxMessageSize = 512
)
 
// Client WebSocket 客户端连接
type Client struct {
    conn   *websocket.Conn
    hub    *Hub
    send   chan []byte
    userID string
    mu     sync.Mutex
}
 
// Hub 维护所有客户端连接
type Hub struct {
    clients    map[*Client]bool
    broadcast  chan []byte
    register   chan *Client
    unregister chan *Client
    mu         sync.RWMutex
}
 
// NewHub 创建 Hub
func NewHub() *Hub {
    return &Hub{
        clients:    make(map[*Client]bool),
        broadcast:  make(chan []byte, 256),
        register:   make(chan *Client),
        unregister: make(chan *Client),
    }
}
 
// Run 启动 Hub
func (h *Hub) Run(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            h.closeAll()
            return
        case client := <-h.register:
            h.mu.Lock()
            h.clients[client] = true
            h.mu.Unlock()
            hlog.CtxInfof(ctx, "client registered: %s", client.userID)
 
        case client := <-h.unregister:
            h.mu.Lock()
            if _, ok := h.clients[client]; ok {
                delete(h.clients, client)
                close(client.send)
            }
            h.mu.Unlock()
            hlog.CtxInfof(ctx, "client unregistered: %s", client.userID)
 
        case message := <-h.broadcast:
            h.mu.RLock()
            for client := range h.clients {
                select {
                case client.send <- message:
                default:
                    close(client.send)
                    delete(h.clients, client)
                }
            }
            h.mu.RUnlock()
        }
    }
}

3.2 WebSocket 读写循环

// readPump 处理读取
func (c *Client) readPump(ctx context.Context) {
    defer func() {
        c.hub.unregister <- c
        c.conn.Close()
    }()
 
    c.conn.SetReadLimit(maxMessageSize)
    c.conn.SetReadDeadline(time.Now().Add(readTimeout))
    c.conn.SetPongHandler(func(string) error {
        c.conn.SetReadDeadline(time.Now().Add(readTimeout))
        return nil
    })
 
    for {
        _, message, err := c.conn.ReadMessage()
        if err != nil {
            if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
                hlog.CtxErrorf(ctx, "websocket read error: %v", err)
            }
            break
        }
 
        // 处理消息
        c.handleMessage(ctx, message)
    }
}
 
// writePump 处理写入
func (c *Client) writePump(ctx context.Context) {
    ticker := time.NewTicker(pingInterval)
    defer func() {
        ticker.Stop()
        c.conn.Close()
    }()
 
    for {
        select {
        case <-ctx.Done():
            return
        case message, ok := <-c.send:
            c.conn.SetWriteDeadline(time.Now().Add(writeTimeout))
            if !ok {
                c.conn.WriteMessage(websocket.CloseMessage, []byte{})
                return
            }
 
            c.mu.Lock()
            err := c.conn.WriteMessage(websocket.TextMessage, message)
            c.mu.Unlock()
            if err != nil {
                return
            }
 
        case <-ticker.C:
            c.conn.SetWriteDeadline(time.Now().Add(writeTimeout))
            if err := c.conn.WriteMessage(websocket.PingMessage, nil); err != nil {
                return
            }
        }
    }
}

3.3 消息类型定义

// MessageType 消息类型
type MessageType int
 
const (
    MessageTypeText   MessageType = iota
    MessageTypeImage
    MessageTypeAudio
    MessageTypeSystem
)
 
// WSMessage WebSocket 消息结构
type WSMessage struct {
    Type      MessageType `json:"type"`
    Content   string      `json:"content"`
    From      string      `json:"from"`
    To        string      `json:"to,omitempty"`
    Timestamp int64       `json:"timestamp"`
}
 
// MarshalJSON 序列化消息
func (m *WSMessage) MarshalJSON() ([]byte, error) {
    type Alias WSMessage
    return json.Marshal(&struct {
        *Alias
        TypeStr string `json:"type_str"`
    }{
        Alias:   (*Alias)(m),
        TypeStr: messageTypeToString(m.Type),
    })
}

4. 业界应用案例

4.1 水滴筹实时消息

场景:捐款实时反馈 方案:WebSocket 推送捐款消息,支撑数百万并发连接 效果:捐款到账延迟 < 500ms

4.2 腾讯会议信令系统

场景:实时会议控制 方案:WebSocket 处理会议信令,控制频道切换 效果:信令延迟 < 50ms

4.3 钉钉消息推送

场景:企业消息实时推送 方案:Hertz + WebSocket 混合架构 效果:单机能支撑 10 万+ 并发连接


5. 业务场景对照

5.1 何时使用 WebSocket

场景推荐方案原因
实时聊天WebSocket双向实时通信
股票行情SSE/WebSocket实时性要求高
文件上传进度SSE单向推送即可
订单状态更新WebSocket实时双向
邮件推送轮询/SSE实时性要求不高

5.2 注意事项

// 错误 1:不设置超时
func badHandler(conn *websocket.Conn) {
    for {
        _, _, err := conn.ReadMessage()  // 没有超时,可能永久阻塞
        if err != nil {
            break
        }
    }
}
 
// 正确做法:设置读写超时
func goodHandler(conn *websocket.Conn) {
    conn.SetReadLimit(maxMessageSize)
    conn.SetReadDeadline(time.Now().Add(readTimeout))
    conn.SetPongHandler(func(string) error {
        conn.SetReadDeadline(time.Now().Add(readTimeout))
        return nil
    })
}
 
// 错误 2:goroutine 泄漏
func badConnection(conn *websocket.Conn) {
    go func() {
        for {
            _, _, err := conn.ReadMessage()  // 连接关闭后 goroutine 可能不退出
            if err != nil {
                return
            }
        }
    }()
}
 
// 正确做法:使用 context 控制生命周期
func goodConnection(ctx context.Context, conn *websocket.Conn) {
    go func() {
        for {
            select {
            case <-ctx.Done():
                return
            default:
                _, _, err := conn.ReadMessage()
                if err != nil {
                    return
                }
            }
        }
    }()
}

6. 常见问题与解答

Q13: WebSocket 代码走读?

答:WebSocket 使用 gorilla/websocket 库,主要包含:

  1. Upgrader 将 HTTP 连接升级为 WebSocket
  2. readPump 循环读取消息
  3. writePump 循环发送消息,配合 ping/pong 保活
  4. Hub 管理所有客户端连接

Q17: Hertz netpoll 模型?

答:Hertz 使用 netpoll(基于 epoll/kqueue)实现高性能 I/O:

  • 非阻塞 I/O,避免阻塞等待
  • 事件驱动,事件触发时调度 handler
  • 配合 goroutine,实现高并发处理

7. 连接健康检查

7.1 WebSocket 心跳机制

const (
    pingInterval = 30 * time.Second
    pongTimeout  = 60 * time.Second
)
 
func (c *Client) startHeartbeat(ctx context.Context) {
    ticker := time.NewTicker(pingInterval)
    defer ticker.Stop()
 
    for {
        select {
        case <-ctx.Done():
            return
        case <-ticker.C:
            c.mu.Lock()
            c.conn.SetWriteDeadline(time.Now().Add(writeTimeout))
            if err := c.conn.WriteMessage(websocket.PingMessage, nil); err != nil {
                c.mu.Unlock()
                hlog.CtxErrorf(ctx, "ping failed: %v", err)
                return
            }
            c.mu.Unlock()
        }
    }
}

7.2 连接状态监控

// ClientState 客户端状态
type ClientState int
 
const (
    StateConnecting ClientState = iota
    StateConnected
    StateReconnecting
    StateDisconnected
)
 
// Monitor 连接监控
func (h *Hub) Monitor() map[ClientState]int {
    h.mu.RLock()
    defer h.mu.RUnlock()
 
    stats := make(map[ClientState]int)
    for client := range h.clients {
        stats[StateConnected]++
    }
    return stats
}