多线程下的websocket实时通信

多线程下的websocket实时通信

//支持dll请看下载文件同名文件

js请求与接收

   //关闭页面断开
                window.onbeforeunload = function () {
                    ws.close();
                }
             //检查浏览器是否支持WebSocketk
                var _this = this;
                var lockReconnect = false;//避免重复连接
                var wsUrl = "ws://127.0.0.1：1818";		// websocket链接
                var ws;
             if (!window.WebSocket) {
                 console.log('您的浏览器不支持WebSocket，请选择其他的浏览器再尝试连接服务器');
             } else {
                 function createWebSocket() {
                     try {
                         ws = new WebSocket(wsUrl);
                         websocketInit();
                     } catch (e) {
                         console.log('catch');
                         websocketReconnect(wsUrl);
                     }
                 }

                 createWebSocket();			// 创建websocket

                 function websocketInit() {
                     // 建立 web socket 连接成功触发事件
                     ws.onopen = function (evt) {
                         onOpen(evt);
                     };
                     // 断开 web socket 连接成功触发事件
                     ws.onclose = function (evt) {
                         websocketReconnect(wsUrl);
                         onClose(evt);
                     };
                     // 接收服务端数据时触发事件
                     ws.onmessage = function (evt) {
                         onMessage(evt);
                     };
                     // 通信发生错误时触发
                     ws.onerror = function (evt) {
                         websocketReconnect(wsUrl);
                         onError(evt);
                     };
                 };

                 function onOpen(evt) {
                     console.log("建立链接");
                     var sendData = { test: 'test' };        // 正常的请求数据
                     sendData = JSON.stringify(sendData);
                     ws.send(sendData);
                     //心跳检测重置
                     heartCheck.start();
                 }

                 function onClose(evt) {
                     console.log("连接已关闭...");
                 }

                 function onMessage(evt) {
                     var data_json1 = JSON.parse(evt.data)
                     //业务逻辑
                     //拿到任何消息都说明当前连接是正常的
                     heartCheck.start();
                 }

                 function websocketReconnect(url) {
                     if (lockReconnect) {       // 是否已经执行重连
                         return;
                     };
                     lockReconnect = true;
                     //没连接上会一直重连，设置延迟避免请求过多
                     tt && clearTimeout(tt);
                     var tt = setTimeout(function () {
                         createWebSocket(url);
                         lockReconnect = false;
                     }, 5000);
                 }

                 //心跳检测
                 var heartCheck = {
                     timeout: 30000,
                     num: 3,  //3次心跳均未响应重连
                     timeoutObj: null,
                     serverTimeoutObj: null,
                     start: function () {
                         var self = this;
                         var _num = this.num;
                         this.timeoutObj && clearTimeout(this.timeoutObj);
                         this.serverTimeoutObj && clearTimeout(this.serverTimeoutObj);
                         this.timeoutObj = setTimeout(function () {
                             //发送测试信息，后端收到后，返回一个消息，
                             ws.send(" ");
                             _num--;
                             //计算答复的超时次数
                             if (_num === 0) {
                                 ws.colse();
                             }
                         }, this.timeout)
                     }
                 }

                 function onError(evt) {
                     console.log('通信错误：' + evt.data);
                 }
             }

开启线程

//加入线程
            isThreadRun = true;
            Thread thread = new Thread(ThreadReadServer);
            thread.IsBackground = true;
            thread.Start();

线程下的websocket

  int count = 0;
    private int timeSleep = 5000;               // 读取的间隔
    private bool isThreadRun = false;          // 用来标记线程的运行状态
    public void ThreadReadServer()
    {

        var allSockets = new List<IWebSocketConnection>();
        var skserver = new WebSocketServer("ws://0.0.0.0:1818");
        skserver.Start(socket =>
        {
            socket.OnOpen = () =>
            {
                Console.WriteLine("Open!");
                allSockets.Add(socket);
            };
            socket.OnClose = () =>
            {
                Console.WriteLine("Close!");
                allSockets.Remove(socket);
            };
            socket.OnMessage = message =>
            {
                //Console.WriteLine(message);
                //allSockets.ToList().ForEach(s => s.Send("Echo: " + message));

                while (isThreadRun)
                {
                    try
                    {
                        //返回数据
                        count++;
                        allSockets.ToList().ForEach(s => s.Send(count.ToString()));
                        Thread.Sleep(timeSleep);
                    }
                    catch (Exception e)
                    {
                        isThreadRun = false;
                    }
                }

            };
        });

    }