WebSocket 的性能优化技术有哪些？

WebSocket 性能优化需要从多个层面进行，包括协议层面、应用层面和架构层面。以下是关键的性能优化技术：

1. 消息压缩

启用 permessage-deflate 扩展

javascript
// 客户端启用压缩
const ws = new WebSocket('wss://example.com/socket', {
  perMessageDeflate: {
    threshold: 1024, // 超过1KB的消息才压缩
    clientMaxWindowBits: 15,
    serverMaxWindowBits: 15,
    clientNoContextTakeover: false,
    serverNoContextTakeover: false
  }
});

// 服务器端（Node.js ws库）
const WebSocket = require('ws');
const wss = new WebSocket.Server({
  perMessageDeflate: {
    threshold: 1024,
    zlibDeflateOptions: {
      level: 3, // 压缩级别 1-9，3是平衡点
      concurrency: 10
    },
    zlibInflateOptions: {
      chunkSize: 10 * 1024
    }
  }
});

压缩效果：

• 文本消息可减少 60-80% 的大小
• JSON 数据压缩效果显著
• 注意：小消息压缩可能反而增加开销

2. 消息批处理和合并

批量发送小消息

javascript
class MessageBatcher {
  constructor(ws, batchSize = 10, batchTimeout = 100) {
    this.ws = ws;
    this.batchSize = batchSize;
    this.batchTimeout = batchTimeout;
    this.messageQueue = [];
    this.batchTimer = null;
  }

  add(message) {
    this.messageQueue.push(message);
    
    if (this.messageQueue.length >= this.batchSize) {
      this.flush();
    } else if (!this.batchTimer) {
      this.batchTimer = setTimeout(() => this.flush(), this.batchTimeout);
    }
  }

  flush() {
    if (this.messageQueue.length === 0) return;
    
    const batch = {
      type: 'batch',
      messages: this.messageQueue,
      timestamp: Date.now()
    };
    
    this.ws.send(JSON.stringify(batch));
    this.messageQueue = [];
    
    if (this.batchTimer) {
      clearTimeout(this.batchTimer);
      this.batchTimer = null;
    }
  }
}

// 使用示例
const batcher = new MessageBatcher(ws);
batcher.add({ type: 'chat', text: 'Hello' });
batcher.add({ type: 'status', value: 'online' });

3. 二进制数据传输

使用二进制格式传输大数据

javascript
// 发送二进制数据
const largeData = new ArrayBuffer(1024 * 1024); // 1MB 数据
ws.send(largeData);

// 使用 ArrayBuffer 和 TypedArray 优化
function sendOptimizedData(ws, data) {
  // 将对象转换为二进制格式
  const buffer = new ArrayBuffer(data.length * 4);
  const view = new Float32Array(buffer);
  
  for (let i = 0; i < data.length; i++) {
    view[i] = data[i];
  }
  
  ws.send(buffer);
}

// 接收二进制数据
ws.binaryType = 'arraybuffer';
ws.onmessage = (event) => {
  if (event.data instanceof ArrayBuffer) {
    const view = new Float32Array(event.data);
    // 处理二进制数据
  }
};

优势：

• 比文本格式更紧凑
• 解析速度更快
• 内存占用更少

4. 连接复用和池化

客户端连接池

javascript
class WebSocketPool {
  constructor(url, poolSize = 3) {
    this.url = url;
    this.poolSize = poolSize;
    this.connections = [];
    this.activeCount = 0;
  }

  async getConnection() {
    // 查找空闲连接
    const available = this.connections.find(ws => 
      ws.readyState === WebSocket.OPEN && !ws.inUse
    );
    
    if (available) {
      available.inUse = true;
      return available;
    }
    
    // 创建新连接
    if (this.connections.length < this.poolSize) {
      const ws = new WebSocket(this.url);
      ws.inUse = true;
      this.connections.push(ws);
      return ws;
    }
    
    // 等待连接释放
    return new Promise(resolve => {
      const checkInterval = setInterval(() => {
        const free = this.connections.find(ws => 
          ws.readyState === WebSocket.OPEN && !ws.inUse
        );
        if (free) {
          clearInterval(checkInterval);
          free.inUse = true;
          resolve(free);
        }
      }, 100);
    });
  }

  releaseConnection(ws) {
    ws.inUse = false;
  }
}

5. 数据结构优化

使用高效的数据格式

javascript
// 使用 Protocol Buffers 替代 JSON
const protobuf = require('protobufjs');

// 定义消息结构
const messageSchema = protobuf.loadSync('message.proto');
const Message = messageSchema.lookupType('Message');

// 编码
const message = Message.encode({
  type: 'chat',
  content: 'Hello',
  timestamp: Date.now()
});

// 发送
ws.send(message.finish());

// 解码
ws.onmessage = (event) => {
  const decoded = Message.decode(new Uint8Array(event.data));
  // 处理解码后的数据
};

性能对比：

• Protocol Buffers: 编码/解码快 5-10 倍
• MessagePack: 比 JSON 小 20-30%
• FlatBuffers: 零拷贝访问

6. 心跳优化

自适应心跳机制

javascript
class AdaptiveHeartbeat {
  constructor(ws, initialInterval = 30000) {
    this.ws = ws;
    this.interval = initialInterval;
    this.minInterval = 5000;
    this.maxInterval = 60000;
    this.rtt = 0;
    this.timer = null;
  }

  start() {
    this.scheduleNextPing();
  }

  scheduleNextPing() {
    this.timer = setTimeout(() => {
      const startTime = Date.now();
      this.ws.send(JSON.stringify({ type: 'ping', timestamp: startTime }));
      
      this.ws.once('message', (data) => {
        const message = JSON.parse(data);
        if (message.type === 'pong') {
          this.rtt = Date.now() - startTime;
          this.adjustInterval();
        }
      });
      
      this.scheduleNextPing();
    }, this.interval);
  }

  adjustInterval() {
    // 根据 RTT 调整心跳间隔
    if (this.rtt < 100) {
      this.interval = Math.min(this.interval * 0.9, this.maxInterval);
    } else if (this.rtt > 500) {
      this.interval = Math.max(this.interval * 1.1, this.minInterval);
    }
  }
}

7. 服务器端优化

使用高性能 WebSocket 库

javascript
// 使用 uWS（比 ws 快 10-20 倍）
const uWS = require('uWebSockets.js');

const app = uWS.App().ws('/*', {
  compression: 1, // 启用压缩
  maxPayloadLength: 16 * 1024 * 1024, // 16MB
  idleTimeout: 60,
  
  open: (ws) => {
    // 连接打开
  },
  
  message: (ws, message, isBinary) => {
    // 处理消息
    ws.send(message, isBinary);
  },
  
  close: (ws, code, message) => {
    // 连接关闭
  }
}).listen(3000, (token) => {
  if (token) {
    console.log('Server started');
  }
});

8. 监控和调优

性能监控指标

javascript
class PerformanceMonitor {
  constructor() {
    this.metrics = {
      messagesSent: 0,
      messagesReceived: 0,
      bytesSent: 0,
      bytesReceived: 0,
      latency: [],
      errors: 0
    };
  }

  recordMessage(size, latency) {
    this.metrics.messagesSent++;
    this.metrics.bytesSent += size;
    this.metrics.latency.push(latency);
    
    // 保持最近1000个样本
    if (this.metrics.latency.length > 1000) {
      this.metrics.latency.shift();
    }
  }

  getStats() {
    const avgLatency = this.metrics.latency.reduce((a, b) => a + b, 0) / 
                       this.metrics.latency.length;
    
    return {
      ...this.metrics,
      avgLatency: avgLatency.toFixed(2),
      throughput: (this.metrics.bytesSent / 1024 / 1024).toFixed(2) + ' MB/s'
    };
  }
}

性能优化建议总结

1. 启用压缩：对大消息使用 permessage-deflate
2. 批处理：合并小消息减少网络往返
3. 二进制格式：使用二进制数据传输大数据
4. 连接复用：避免频繁创建连接
5. 高效序列化：使用 Protocol Buffers 等格式
6. 自适应心跳：根据网络状况调整心跳间隔
7. 高性能库：使用 uWS 等优化库
8. 监控调优：持续监控性能指标并优化