我正在创建一个 Web 应用程序，它需要非常频繁地从服务器向客户端发送少量数据(每个套接字 3 个整数值)，我想看看是否有更新客户端的最大频率使用Socket.IO .

我希望实现至少 50 个套接字连接，每个连接每秒发送 20 个更新。理想的数量是 200 个套接字连接，每秒发送 50 个更新。

问题:使用 Socket.IO 发送新数据的频率是否有限制？

注意:我认识到这也成为服务器-客户端连接的速度问题，因此非常感谢任何关于我需要多快连接的信息。我计算出如果发送的每个数据包大约为 500 字节，那么我将能够在 1 MB/s 的连接上每秒发送 20 个更新到 100 个连接。

最佳答案

这是一个非常依赖于系统、网络和代码的问题。

这是我之前用于类似普通 socket.io 测试的小型测试工具，我插入了一些位来满足您的问题。

服务器

const io = require('socket.io')(8082)
const connections = []

io.on('connection', function(socket){

  connections.push(socket);
  const slog = (msg, ...args) => console.log('%s %s '+msg, Date.now(), socket.id, ...args)
  slog('Client connected. Total: %s', connections.length)

  socket.on('disconnect', function(data){
    connections.splice(connections.indexOf(socket), 1);
    slog('Client disconnected. Total: %s', connections.length)
  })

  socket.on('single', function(data){
    socket.emit('single',[ 0, now, now, now ])
  })

  socket.on('start', function(data = {}){
    slog('Start stream', data)
    sendBatch(1, data.count, data.delay)
  })

  socket.on('start dump', function(data = {}){
    slog('Start dump', data)
    sendBatch(1, data.count)
  })

  function sendBatch(i, max, delay){
    if ( i > max ) return slog('Done batch %s %s', max, delay)
    socket.emit('batch',[ i, now, now, now ])
    if (delay) {
      setTimeout(()=> sendBatch(i++, max, delay), delay)
    } else {
      setImmediate(()=> sendBatch(i++, max))
    }
  }

})

客户端

const io = require('socket.io-client')
const socket = io('http://localhost:8082', {transports: ['websocket']})

socket.on('connect_error', err => console.error('Socket connect error:', err))
socket.on('connect_timeout', err => console.error('Socket connect timeout:', err))
socket.on('reconnect', err => console.error('Socket reconnect:', err))
socket.on('reconnect_attempt', err => console.error('Socket reconnect attempt:', err))
socket.on('reconnecting', err => console.error('Socket reconnecting', err))
socket.on('reconnect_error', err => console.error('Socket reconnect error:', err))
socket.on('reconnect_failed', err => console.error('Socket reconnect failed:', err))

function batch(n){
  socket.on('batch', function(data){
    if ( data[0] >= n ) {
      let end = Date.now()
      let persec = n / (( end - start ) / 1000)
      console.log('Took %s ms for %s at %s/s', end - start, n, persec.toFixed(1))
      return socket.close()
    }
  })
}

function startDump(count = 500000){
  socket.emit('start dump', { count: count })
  console.log('Start dump', count)
  batch(count)
}
function startStream(count = 50, delay = 1000){
  socket.emit('start', { count: count, delay: delay })
  console.log('Start stream', count, delay)
  batch(count)
}

function pingIt(i, max = 50){
  socket.on('single', function(data){
    console.log('Got a single with:', data)
    if (i >= max) {
      let end = Date.now()
      let persec = i / (end - start) * 1000
      console.log('Took %s ms %s/s', end - start, persec.toFixed(2))
      return socket.close()
    }
    socket.emit('single', i+=1)
  })
  socket.emit('single', i)
}

let start = Date.now()

//console.log('args command: %s  count: %s  delay: %s',process.argv[2], process.argv[3], process.argv[4])
switch(process.argv[2]){
  case 'ping':   pingIt(0, process.argv[3]); break
  case 'stream': startStream(process.argv[3], process.argv[4]); break
  case 'dump':   startDump(process.argv[3]); break
  default:       console.log('ping stream dump'); socket.close()
}

测试请求/响应往返

 node socketio-client.js ping 4

为了测试吞吐量，尽可能快地转储消息。

 node socketio-client.js dump 100000

测试 1000 条消息的流，每条消息之间有 18 毫秒的延迟，大约是每秒 50 条消息。

 node socketio-client.js stream 1000 18

在我的开发机器上，我可以每秒将大约 40000 条消息转储到单个本地主机客户端，并将 4 个整数作为 2 GHz CPU 上的有效负载(计数器 + 3 个时间戳)。服务器和客户端 node 进程各自使用 95-100% 的 CPU 内核。所以纯吞吐量看起来还不错。

我可以每秒向 100 个本地客户端发送 100 条消息，服务器进程的 CPU 使用率为 55%。

我的开发机器上的单个 node 进程每秒无法向 100 个客户端发送超过 130-140 条消息。

新的高频 Intel Skylake CPU 服务器可能会在本地消除这些数字。添加一个可能很不稳定的网络连接，它会立即恢复正常。除了本地网络延迟之外的任何事情都可能会扰乱您认为通过如此高的消息速率可以获得的 yield 。任何较慢的延迟抖动都会对客户端消息的“帧速率”造成严重破坏。可能需要给消息加上时间戳并在客户端跟踪它们。

如果您遇到问题，也可以使用较低级别的 websocket 库，例如 ws这将需要您进行更多实现，但会让您更好地控制套接字连接，并且您可能会从中获得更多性能。

您拥有的连接越多，您与其余代码和套接字代码的争用就越多。您可能最终需要使用 multiple nodes让事情顺利进行。 Cluster can split the app across multiple Node.js processes .你可能需要像 Redis 这样的东西，ZeroMQ或 Nanomsg管理IPC。 Node 9 中的 V8 支持 SharedArrayBuffer和 Atomics但在 Node 中还没有太多内容用于 workers。

关于javascript - 使用 Socket.IO 发送数据的频率如何？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/47275123/