Go netpoll 与 WebSocket 长连接通识

Hello,我是小兔大白糖。 读完能把事件驱动网络与长连接会话管理分开讲,并意识到背压与心跳合同。
netpoll管事件驱动 I/O;WebSocket 长连接还要另写会话、心跳与背压合同。
估计阅读时间:12 分钟
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 库,主要包含:
Upgrader将 HTTP 连接升级为 WebSocketreadPump循环读取消息writePump循环发送消息,配合 ping/pong 保活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
}