C# WebSocket高并发通信阻塞问题-数字星空

项目上遇到使用WebSocket超时问题，具体情况是这样的，OTA升级过程中，解压zip文件会有解压进度事件，将解压进度通过进程通信传给另一进程，通信提示超时异常

小伙伴堂园发现大文件使用Zip解压，解压进度事件间隔竟然是1ms，简直超大频率啊

但是，解压事件超频也不应该通信异常啊，于是我通过1ms定时发送通信事件，测试了下进程间通信流程。

WebSocketSharp

当前进程间通信组件是基于kaistseo/UnitySocketIO-WebSocketSharp实现，主机内设置一服务端，多个客户端连接服务端，客户端通信由服务端转发数据。客户端A发送给B后，客户端B会将执行结果反馈给客户A。

那在定位中发现，各个链路发送延时都是正常的，包括服务端发送反馈数据给到客户端A，但客户端A接收数据延时很大，下面是部分返回数据：

并且通信时间久了之后，延时会越来越大

这里是WebSocketSharp.WebSocket对外事件OnMessage：

 1     private void WebSocketOnMessage(object sender, MessageEventArgs e)
 2     {
 3         if (!e.IsText)
 4         {
 5             //暂时不支持
 6             return;
 7         }
 8         Debug.WriteLine($"{DateTime.Now.ToString("HH:mm:ss fff")},{e.Data}");
 9 
10         var receivedMessage = JsonConvertSlim.Decode<ChannelServerMessage>(e.Data);
11         xxxxx
12     }

我们继续往下看，OnMessage是由WebSocket.message()触发，从_messageEventQueue队列中获取数据：

 1     private void message ()
 2     {
 3       MessageEventArgs e = null;
 4       lock (_forMessageEventQueue) {
 5         if (_inMessage || _messageEventQueue.Count == 0 || _readyState != WebSocketState.Open)
 6           return;
 7 
 8         _inMessage = true;
 9         e = _messageEventQueue.Dequeue ();
10       }
11 
12       _message (e);
13     }

循环接收数据是这样拿的：

 1     private void startReceiving ()
 2     {
 3       xxxx
 4       _receivingExited = new ManualResetEvent (false);
 5       Action receive = () => WebSocketFrame.ReadFrameAsync (_stream, false,
 6             frame => {
 7               if (!processReceivedFrame (frame) || _readyState == WebSocketState.Closed) {
 8                 var exited = _receivingExited;
 9                 if (exited != null)
10                   exited.Set ();
11                 return;
12               }
13               // Receive next asap because the Ping or Close needs a response to it.
14               receive ();
15               xxxx
16               message ();
17             },
18             xxxx
19           );
20       receive ();
21     }

这里我看到了ManualResetEvent。。。数据量那么大，这里搞个同步信号锁，肯定会堵住咯

为何设置线程同步锁呢？我们往下看

WebSocketSharp数据发送是基于TCPClient实现的：

1     _tcpClient = new TcpClient (_proxyUri.DnsSafeHost, _proxyUri.Port);
2     _stream = _tcpClient.GetStream ();

初始化后通过_stream.Write (bytes, 0, bytes.Length);发送数据

接收数据，也是通过_stream读取，可以看上方的startReceiving()方法里，WebSocketFrame.ReadFrameAsync (_stream, false,...)

我们知道，TCP是面向连接，提供可靠、顺序的数据流传输。用于一对一的通信，即一个TCP连接只能有一个发送方和一个接收方。具体的可以看我之前写的文章：.NET TCP、UDP、Socket、WebSocket - 唐宋元明清2188 - 博客园 (cnblogs.com)

但接收时在高并发场景下，适当的同步措施依然是必需的。我们可以使用lock也可以用SemaphoreSlim来实现复杂的同步需求，这里使用的是信号锁ManualResetEvent

我们再看看发送端代码，也是用了lock一个object来限制并发操作：

 1     private bool send (Opcode opcode, Stream stream)
 2     {
 3       lock (_forSend) {
 4         var src = stream;
 5         var compressed = false;
 6         var sent = false;
 7         xxxxx 
 8         sent = send (opcode, stream, compressed);
 9         xxxxx 
10         return sent;
11       }
12     }

所以WebSocketSharp在高并发场景下是存在通信阻塞问题的。当然，WebSocketSharp已经实现的很好了，正常的话几ms都不会遇到阻塞问题，如下设置10ms定时超频发送：

客户端A发送消息，由服务端转发至客户B，再将客户端B的反馈结果由服务端转发回客户端A，真正延时才0-2ms！

WebSocket

我们再看看原生的WebSocket，写个WebSocket通信Demo kybs00/WebSocketDemo (github.com)

服务端定时1ms使劲往客户端发送Message消息，结果竟然是：

System.InvalidOperationException:“There is already one outstanding 'SendAsync' call for this WebSocket instance. ReceiveAsync and SendAsync can be called simultaneously, but at most one outstanding operation for each of them is allowed at the same time.”

看来发送事件外部也要处理好高并发的场景，1ms真的是太猛了

 1     private SemaphoreSlim _sendLock = new SemaphoreSlim(1);
 2     private async void Timer_Elapsed(object sender, ElapsedEventArgs e)
 3     {
 4         var message = $"{DateTime.Now.ToString("HH:mm:ss fff")},hello from server";
 5 
 6         await _sendLock.WaitAsync();
 7         await BroadcastAsync("test", message);
 8         _sendLock.Release();
 9         Console.WriteLine(message);
10     }