socket.io线上生产环境有经验的请进

samoin 1楼•2年前

补充下，我在代码里还用到了cluster，默认配置只启动一个子进程

sumory 2楼•2年前

确定你的浏览器支持websocket？
禁用htmlfile协议，如果启用了，它与gzip是不相容的，忘了具体原因，现在也没空给你看线上配置
前端可以禁止socket.io重连配置，你自己监控disconnect事件，然后重连

samoin 3楼•2年前

首先，感谢您的回复

确定你的浏览器支持websocket？这个应该不是重点，用socket.io就是想利用他现成的长连接的解决方案

禁用htmlfile协议，如果启用了，它与gzip是不相容的，忘了具体原因，现在也没空给你看线上配置这个是否说要在transports策略中去掉htmlfile

前端可以禁止socket.io重连配置，你自己监控disconnect事件，然后重连现在我用的是默认的自动连接方案，回头我试下。

顺便问下，请问你们现在线上的服务是要求用户使用只支持websocket的浏览器吗？

sumory 4楼•2年前

websocket不是长连接，是全双工
线上我把websocket和htmlfile都关了，只剩jsonp-polling和xhr-polling。

samoin 5楼•2年前

哦，行吧，谢谢

samoin 6楼•2年前

问题依旧，郁闷，总会有这种不断连接的现象出现，从而导致端口不释放出问题。 (node) warning: possible EventEmitter memory leak detected. 11 listeners added. Use emitter.setMaxListeners() to increase limit. Trace at Socket.EventEmitter.addListener (events.js:160:15) at Socket.Readable.on (_stream_readable.js:663:33) at Socket.EventEmitter.once (events.js:179:8) at TCP.onread (net.js:527:26)

我已经按照网上的一些做法对app，io以及process都增加了设置 app.setMaxListeners(0); process.setMaxListeners(0); io.setMaxListeners(0); 但是仍然出现问题，求各种help

samoin 7楼•2年前

出问题的时候，node的进程cpu占满，请求过去一直不会返回。

sumory 8楼•2年前

你的代码应该写的有问题，方便贴出来吗？

samoin 9楼•2年前

方便，这个需要全部贴出来吗？还是只需要其中某一部分

samoin 10楼•2年前

配置文件socket.io-chat-loginpro.js var arr = []; arr.push({pass : “admin” , pwd : “admin123456” , type : "admin"}); var socketioProperty = { “log level” : 0 , “transports” : [“websocket” , “xhr-polling” , “jsonp-polling”] , “close timeout” : 25 , “heartbeat timeout” : 25 , “heartbeat interval” : 12 , “polling duration” : 10};

//服务开放的端口号 exports.port=443; //用来配置后台可登录的用户，这里没有数据落地，如需数据落地，可进行相关代码的修改 exports.userList=arr; //对express的logger的配置，调用为app.use(express.logger(‘dev’)); exports.expressLogger=""; //对socket.io的一些设置，目前只做了这一些，如有需求，可继续添加和修改 exports.socketioProperty = socketioProperty; //memoryStore的ReapInterval exports.memoryStoreReapInterval = 1000 * 60 * 10; //session的Secret-key exports.sessionSecret = 'socket.io-chat’; //是否允许唯一key多个浏览器窗口登录 exports.canMoreClientForUqKey = true; //在不允许唯一key多个浏览器窗口登录的前提下，是否发送脚本踢掉上一个登录用户 exports.kickMoreClientForUqKey = true; //如需要踢人，对应调用的函数名 exports.kickMoreClientForUqKeyFuncName = "chat.kickUser()"; //启动node对应的主文件名，用来统计资源消耗用 exports.appName = "socket.io-chat.js"; //统计日志的间隔时间，秒为单位 exports.staticSec = 60; //服务对应的外网地址和port exports.workUrl="http://127.0.0.1:443"; //mongodb的集群的地址，建议您使用repSet集群配置 exports.mongodbRep = "mongodb://127.0.0.1:47022,127.0.0.1:47023";

主文件socket.io-chat.js var loginPro = require(“./socket.io-chat-loginpro”) , routesIndex = require(‘./routes/index’); var exec = require(‘child_process’).exec; //服务对应的外网地址和port var workUrl = loginPro.workUrl; //启动node对应的主文件名，用来统计资源消耗用 var appName = loginPro.appName; //统计日志的间隔时间，秒为单位 var staticSec = loginPro.staticSec; //是否允许唯一key多个浏览器窗口登录 var canMoreClientForUqKey = loginPro.canMoreClientForUqKey; //在不允许唯一key多个浏览器窗口登录的前提下，是否发送脚本踢掉上一个登录用户 var kickMoreClientForUqKey = loginPro.kickMoreClientForUqKey; //如需要踢人，对应调用的函数名 var kickMoreClientForUqKeyFuncName = loginPro.kickMoreClientForUqKeyFuncName; //该进程内的所有聊天室的相关信息，map结构 var chatMap = {}; //命令的备注(尽量不要修改，在前台的js调用中需同步复制一份，并遵循命令规则) cmdObj = {"register" : 1 , “leave” : 2 , “talk” : 3 , “func” : 4}; // 当前在线用户人数 var userCount = 0; var parseCookie = require(‘connect’).utils.parseCookie , MemoryStore = require(‘connect/lib/middleware/session/memory’); //建立一个memory store的实例 var storeMemory = new MemoryStore({ reapInterval: loginPro.memoryStoreReapInterval }); var express = require(‘express’), app, server, io; app = express(); app.setMaxListeners(0); var cluster = require(‘cluster’); // mongodb var clusterList = require(“./model/clusterList”) ,clusterListDao = clusterList.dao; var chatQueen = require(“./model/chatQueen”) ,chatQueenDao = chatQueen.dao; // 最新同步记录的最大时间 var lastSyncDate = new Date().getTime(); // 是否正在进行同步的相关操作 var isSyncQueen = false; if (cluster.isMaster) { var numCPUs = require(‘os’).cpus().length; numCPUs = 1; for ( var i = 0; i < numCPUs; i++) { cluster.fork(); } //server.serverCluster = cluster.workers; // this is for version 0.8.x + cluster.on('exit’, function(worker, code, signal) { console.log(“worker " , worker.process.pid , " exit , restarting …”); cluster.fork(); }); } else if(cluster.isWorker){ process.setMaxListeners(0); createServer(); }

function createServer(){ startSyncMongodb(true); }

}

function startServer(){ setInterval(function(){getResByShell();},staticSec * 1000); server = require(‘http’).createServer(app); io = require(‘socket.io’).listen(server); io.setMaxListeners(0); server.listen(loginPro.port);

    if(loginPro.expressLogger){
        app.use(express.logger(loginPro.expressLogger));
    }

    //对socket.io进行一些基本的设置
    if(loginPro.socketioProperty){
        for(var key in loginPro.socketioProperty){
            var value = loginPro.socketioProperty[key];
            io.set(key , value);
        }
    }

    // Configuration，对app进行设置
    app.configure(function(){
      app.use(express.bodyParser());//解析post
      app.use(express.cookieParser());//解析cookie
      //设置session
      app.use(express.session({
              secret : loginPro.sessionSecret,
              store : storeMemory
      }));

      app.set('views', __dirname + '/views');
      app.set('view engine', 'jade');
      app.use(app.router);
      app.use(express.static(__dirname + '/public'));
      app.use(express.static(__dirname + '/config'));
    });

    /**增加对所有链接的过滤*/
    app.all("/*",function(req,res,next){
        next();
    });
    //进入聊天室
    app.get("/chat",routesIndex.chat);
    //默认欢迎页
    app.get("/index",routesIndex.index);
    //登录页
    app.get("/login",routesIndex.login);
    //登录的提交页
    app.post("/login",routesIndex.loginPost);
    //用户在线的查询
    app.get("/onlineUserList",function(req,res){
        var room = req.query.room;
        var pass = req.query.pass;
        res.json(renderChatMapJson(room,pass,false));
    });
    //用户在线的详细信息的查询
    app.get("/onlineUserInfoList",function(req,res){
        var room = req.query.room;
        var pass = req.query.pass;
        res.json(renderChatMapJson(room,pass,true));
    });

    io.sockets.on('connection', function (socket) {
      // 用户断开后的处理
      socket.on('disconnect', function (data) {
        var moduleKey = socket["moudle"];
        var uqKey = socket["uqKey"];
        var randomKey = socket["randomKey"];
        insertChatQueen({cmd : cmdObj["leave"] , msg : {ip : socket["ip"] , uqKey : uqKey , randomKey : socket["randomKey"] , userAgent : socket["userAgent"] , moudle : socket["moudle"]}});
        //console.log("log >",getNow(),",",{cmd : cmdObj["leave"] , msg : {uqKey : uqKey}});
        if(!data || data.toString() == "close timeout" || data.toString() == "socket end"){
            if(chatMap[moduleKey] && chatMap[moduleKey][uqKey] && getCountFromMap(chatMap[moduleKey][uqKey]) == 1){
                emitByMoudle(moduleKey , {cmd : cmdObj["leave"] , msg : {uqKey : uqKey}});
            }
            if(chatMap[moduleKey] && chatMap[moduleKey][uqKey]){
                delete(chatMap[moduleKey][uqKey][randomKey]);
                //console.log("<>" , getCountFromMap(chatMap[moduleKey][uqKey]));
            }
            if(chatMap[moduleKey] && chatMap[moduleKey][uqKey] && getCountFromMap(chatMap[moduleKey][uqKey]) == 0){
                delete(chatMap[moduleKey][uqKey]);
                //console.log(">>>>>>" , JSON.stringify(chatMap[moduleKey][uqKey]));
            }
        }

      });
      socket.on('msgs', function (data) {
          // 用户在建立连接后的注册操作
          if(data.cmd == cmdObj["register"]){
            var msg = data.msg;
            var moduleKey = msg.moudle;
            var uqKey = msg.uqKey;
            var randomKey = msg.randomKey;
            //console.log(moduleKey ,",",uqKey,",",randomKey, ">>>>>>>registed" , ",", data);
            socket["ip"] = socket.handshake.address.address; 
            socket["uqKey"] = uqKey;
            socket["userAgent"] = msg.userAgent;
            socket["moudle"] = moduleKey;
            socket["randomKey"] = randomKey;
            if(!chatMap[moduleKey]){
                chatMap[moduleKey] = {};
            }
            if(!chatMap[moduleKey][uqKey]){
                chatMap[moduleKey][uqKey] = {};
            }
            if( !canMoreClientForUqKey){
                if(kickMoreClientForUqKey && getCountFromMap(chatMap[moduleKey][uqKey]) > 0){
                    //console.log(moduleKey ,",",uqKey,",",randomKey, ">>>>>>>" ,getCountFromMap(chatMap[moduleKey][uqKey]));
                    // 这里通过函数方式给客户端传递函数调用
                    emitByMap(moduleKey,chatMap[moduleKey][uqKey] , {cmd : cmdObj["func"] , msg : {func : kickMoreClientForUqKeyFuncName }});
                    insertChatQueen({cmd : cmdObj["func"] , msg : {func : kickMoreClientForUqKeyFuncName, ip : socket["ip"] , uqKey : uqKey , randomKey : socket["randomKey"] , userAgent : socket["userAgent"] , moudle : socket["moudle"]}});
                }
                chatMap[moduleKey][uqKey] = {};
            }
            
            chatMap[moduleKey][uqKey][randomKey] = socket;      
            if(getCountFromMap(chatMap[moduleKey][uqKey]) == 1){
                emitByMoudle(msg.moudle , data);
            }else{
                emitBySocket(moduleKey,socket,data);
            }
            data.msg.ip = socket["ip"];
          }
          // 用户常用的聊天内容的操作
          if(data.cmd == cmdObj["talk"]){
            var msg = data.msg;
            var toId = msg.toId;
            var moduleKey = socket["moudle"];
            if(toId == ""){
                //console.log(moduleKey, "emit to all");
                emitByMoudle(moduleKey , data);
            }else{
                //console.log(moduleKey, "emit to  <" + toId + ">");
                emitByMoudleAndId(moduleKey , toId , data);
                emitByMoudleAndId(moduleKey , socket["uqKey"] , data);
            }
            data.msg.ip = socket["ip"];
            data.msg.userAgent = socket["userAgent"];
            data.msg.randomKey = socket["randomKey"];
            data.msg.uqKey = socket["uqKey"];
          }
          //TODO 这里将来考虑数据落地，作为聊天记录的原始依据，现在暂时记录日志中
          //console.log("log >",getNow(),",",JSON.stringify(data));
          insertChatQueen(data);
      });
    });
}

根据传入的条件，返回当前用户在线状态的结果集，Map结构
@params room 所在房间id
@params pass 用户的唯一passport
@params isWithInfo 是否返回相关信息，如不存在或false则返回对应的计数
@return map<key,map<key,array>> **/ function renderChatMapJson(room,pass,isWithInfo){ var result = {}; for(var k1 in chatMap){ var v1 = chatMap[k1]; if(room && room != k1){ if(!pass){ continue; } } result[k1] = {}; if(v1){ var tmpCount = 0 ; for(var k2 in v1){ if(pass){ if(pass == k2){ if(!room || (room && room == k1)){ result[k1][k2] = isWithInfo ? getStaticInfoFromMap(v1[k2]) : getCountFromMap(v1[k2]); tmpCount++; } } }else{ result[k1][k2] = isWithInfo ? getStaticInfoFromMap(v1[k2]) : getCountFromMap(v1[k2]); tmpCount++; } } if(tmpCount == 0){ delete(result[k1]); } } } return result; }

//根据所在模块(房间)给该模块下的所有socket推送消息 function emitByMoudle(moudleKey , data){ for(var key in chatMap[moudleKey]){ emitByMoudleAndId(moudleKey , key , data); } } //根据所在模块(房间)给对应的唯一id推送消息 function emitByMoudleAndId(moudleKey , uqId , data){ if(chatMap[moudleKey]){ var socketTmpObj = chatMap[moudleKey][uqId]; //console.log(uqId); emitByMap(moudleKey,socketTmpObj,data); }else{ console.log(“key > “,moudleKey,” does not exist in chatMap,no socket to send…”); } } //根据所在模块(房间)给对应的socket集合推送消息 function emitByMap(moudleKey,socketTmpObj,data){ for(var key in socketTmpObj){ var socketTmp = socketTmpObj[key]; emitBySocket(moudleKey,socketTmp,data) } } //根据所在模块(房间)给对应的socket推送消息 function emitBySocket(moudleKey,socketTmp,data){ if(socketTmp){ try{ // 下面的代码，从逻辑上和真实处理是一致的，但是没有对应的socket，为了满足之前的value结构，所以用一个模拟的对象来代替，在发送的时候要注意排除给这些对象的发送 if(!socketTmp.isDummySocekt){ socketTmp.emit(“msgs” , data); } }catch(e){ console.log("emit error >> " , e); } }else{ delete(chatMap[moudleKey][uqId][key]); } } //从object（map）对象中，返回存在的key的个数 function getCountFromMap(map){ var count = 0; for(var key in map){ count++; } return count; } //从object（map）对象中，返回存在的key的详细信息汇总 function getStaticInfoFromMap(map){ var arr = [];; for(var key in map){ var objTmp = map[key]; var tmp = {}; tmp[“ip”] = objTmp[“ip”]; tmp[“uqKey”] = objTmp[“uqKey”]; tmp[“moudle”] = objTmp[“moudle”]; tmp[“randomKey”] = objTmp[“randomKey”]; arr.push(tmp); } return arr; } function judgeErrorConnect(){

return false;

} var currentCountArr = []; // 获取当前node所占的资源 function getResByShell() { //"ps aux| grep ‘node’ " dir exec("ps aux| grep ‘node’ ", function(err, output) { if (err) { throw err; } if (output.length > 0) { // USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND // root 1211 0.0 0.1 659800 10512 ? Sl Mar13 0:36 node app2.js var tmpArr = output.split(“\n”); var resultArr = new Array(); for ( var i = 0; i < tmpArr.length; i++) { var infoTmp = tmpArr[i]; if (typeof (infoTmp) == “object”) { continue; } var infoTmpArr = infoTmp.split(" "); var tmpIndex = 0; var nodeInfo = {}; if (infoTmpArr.length < 2) { continue; } for ( var j = 0; j < infoTmpArr.length; j++) { var infoTmpArrTmp = infoTmpArr[j]; if (infoTmpArrTmp.replace(/ /gim, “”).length > 0) { if (tmpIndex == 0) { nodeInfo[“USER”] = infoTmpArrTmp; } if (tmpIndex == 1) { nodeInfo[“PID”] = infoTmpArrTmp; } if (tmpIndex == 2) { nodeInfo[“%CPU”] = infoTmpArrTmp; } if (tmpIndex == 3) { nodeInfo[“%MEM”] = infoTmpArrTmp; } if (tmpIndex == 4) { nodeInfo[“VSZ”] = infoTmpArrTmp; } if (tmpIndex == 5) { nodeInfo[“RSS”] = infoTmpArrTmp; } if (tmpIndex == 6) { nodeInfo[“TTY”] = infoTmpArrTmp; } if (tmpIndex == 7) { nodeInfo[“STAT”] = infoTmpArrTmp; } if (tmpIndex == 8) { nodeInfo[“START”] = infoTmpArrTmp; } if (tmpIndex == 9) { nodeInfo[“TIME”] = infoTmpArrTmp; } if (tmpIndex == 10) { nodeInfo[“COMMAND1”] = infoTmpArrTmp; } if (tmpIndex == 11) { nodeInfo[“COMMAND2”] = infoTmpArrTmp; } tmpIndex++;

                    }
                }
                if ((nodeInfo["COMMAND1"] && nodeInfo["COMMAND1"].indexOf(appName) >= 0)
                        || (nodeInfo["COMMAND2"] && nodeInfo["COMMAND2"].indexOf(appName) >= 0)) {
                    resultArr.push(nodeInfo);
                }
            }
            //console.log(renderChatMapJson());
            var logInfo = 'static > {time:"' + getNow() + '" , totalCount:"' + renderAllChatMapJsonStr(true) + '" , info:'
                    + JSON.stringify(resultArr) + '}';
            console.log(logInfo);
            currentCountArr.push(logInfo);
            getLastChatQueenList(lastSyncDate);
            startSyncMongodb();
        }
    })

}

// extend Date Date.prototype.format = function(format) { var o = { “M+” : this.getMonth() + 1, // month “d+” : this.getDate(), // day “h+” : this.getHours(), // hour “m+” : this.getMinutes(), // minute “s+” : this.getSeconds(), // second “q+” : Math.floor((this.getMonth() + 3) / 3), // quarter “S” : this.getMilliseconds() // millisecond }

if (/(y+)/.test(format)) {
    format = format.replace(RegExp.$1, (this.getFullYear() + "")
            .substr(4 - RegExp.$1.length));
}

for ( var k in o) {
    if (new RegExp("(" + k + ")").test(format)) {
        format = format.replace(RegExp.$1, RegExp.$1.length == 1 ? o[k]
                : ("00" + o[k]).substr(("" + o[k]).length));
    }
}
return format;

} function getNow() { return getNowByFmt(“yyyy-MM-dd hh:mm:ss”); } function getToday() { return getNowByFmt(“yyyy-MM-dd”); } function getNowByFmt(fmt) { return new Date().format(fmt); } function getDateByFmt(date,fmt) { return date.format(fmt); }

其它的如route文件和mongoose的文件还需要贴吗。整体写的比较乱，想做的就是一个实时在线的服务

samoin 11楼•2年前

前端页面里的代码 <input id="chatName" type="hidden"/><input id="chatUserName" type="hidden"/>

js文件browser.js var browserInfo = navigator.userAgent; var socketioHttp = "http://XX.XX.XX.XX:443";

chat.socket.on("connect",function(){
    //var random = browserInfo + "-" + new Date().getTime() + "-" + parseInt(Math.random() * 10000);
    var random = new Date().getTime() + "-" + parseInt(Math.random() * 10000);
    chat.socket.emit("msgs" , {cmd : chat.cmdObj["register"] , msg : {uqKey : chat.userName , moudle : chat.moudle , randomKey : random , userAgent : browserInfo}});
});
chat.socket.on("disconnect",function(){
    reconnectInterval = setInterval(function(){chat.connectSocketIo();} , 5 * 1000);
});
chat.socket.on('reconnect', function(){
    //console.log("Reconnected to Server"); 
    clearInterval(reconnectInterval);
});
chat.socket.on('reconnecting', function( nextRetry ){ 
    //console.log("Reconnecting in " + nextRetry + " seconds"); 
});
chat.socket.on('reconnect_failed', function(){
    //console.log("Reconnect Failed"); 
});

chat.socket.on('msgs', function (data) {
    var msg = data.msg;
    if(data.cmd == chat.cmdObj["register"]){
        var ele = $("#chat_msg");
        $("#login").hide();
        if(msg.uqKey != chat.userName){
            var msg = "<p><a href='#' onclick='chat.changeTalk(\"" + msg.uqKey + "\");'>" + msg.uqKey + "</a>进入直播室</p>";
            ele.append(msg);
        }
        $("#chat").show();
    }
    if(data.cmd == chat.cmdObj["leave"]){
        var ele = $("#chat_msg");
        $("#login").hide();
        var msg = "<p>" + msg.uqKey +"离开直播室</p>";
        ele.append(msg);
        $("#chat").show();
    }
    if(data.cmd == chat.cmdObj["talk"]){
        var ele = $("#chat_msg");
        $("#login").hide();
        var msg = "<p>" + (msg.from == chat.userName ? "我" : "<a href='#' onclick='chat.changeTalk(\"" + msg.from + "\");'>" + msg.from + "</a>") +" 对 " + (msg.toId == "" ? "<a href='#' onclick='chat.changeTalk(\"\");'>大家</a>" : (msg.toId == chat.userName ? "我" : "<a href='#' onclick='chat.changeTalk(\"" + msg.toId + "\");'>" + msg.toId + "</a>")) + "说:" + msg.info + "</p>";
        ele.append(msg);
        $("#chat").show();
        $("#chat_msg").scrollTop($("#chat_msg").scrollTop() + 100);
    }
    if(data.cmd == chat.cmdObj["func"]){
        var func = msg.func;
        eval(func);
    }
});

}; chat.talk = function(){ var talk_info = $(“#talk_info”).val(); var to_id = $(“#to_id”).val(); chat.socket.emit(“msgs” , {cmd : chat.cmdObj[“talk”] , msg : {from : chat.userName ,moudle : chat.moudle ,info : talk_info , toId : to_id}}); $(“#talk_info”).val(“”); }; chat.changeTalk = function(uqName){ $(“#to_id”).val(uqName); };

samoin 12楼•2年前

顺便问下，您用的是node.js的什么版本，我在这个地方用的是v0.10.5，之前在另台机器上写了一个类似的服务，但是没用express和mongodb，那个是用的v0.6.12，那个就不会出这问题。今天看到一个老外的帖子遇到类似的问题，他是在9和10版本出现，8这个版本就不会。如您看到，请帮我查看下对应的版本，谢谢。

sumory 13楼•2年前

我用的node0.8.22，没有用mongodb，用了express3

sumory 14楼•2年前

你的代码太多了？看得晕。你先把自动重连给禁用了：

socket = io.connect(url, {reconnect:false});

然后自己写重连,大体是这样的：

socket.on('disconnect', function() {
    console.log('连接已断开...');
    intervalID = setInterval(function(){
        socket.socket.reconnect();
        clearInterval(intervalID);   
    }, 4000);
});

然后你查看下客户端日志，验证下重连的情况。我猜测你那个短时间内重练了1000多次，是因为那个浏览器使用的通信协议不对，然后一直连不上。

sunuxreg 15楼•2年前

请问intervalID = setInterval(function(){}，这句是做什么用的啊？

sumory 16楼•2年前

@sunuxreg 定时轮询、重连

sunuxreg 17楼•2年前

@sumory Socket.IO基于WebSocket，不是没有轮询吗？

samoin 18楼•2年前

你说的这个，我已经修改了，去掉了自动重连，然后在client里增加了相关的重连代码。按照你这样的情况来看，我大概确定怎么回事了，结合我之前功能的使用版本v0.6.x，应该是node.js的版本问题，我今天看了一篇国外的帖子，他那边跟我类似也是出现这种情况，V0.8.X版本正常，但是用到9，10就出现我这种报错。感谢您最近这段时间的解答，后面我会切换回旧版本的node.js，传送们 https://github.com/joyent/node/issues/5108#issuecomment-16897815

sumory 19楼•2年前

@sunuxreg 谁说的socketio是基于websocket的？

sumory 20楼•2年前

@samoin 不错！找到问题就好

samoin 21楼•2年前

@sumory 个人觉得，socket.io相当于提供了一套解决方案，可以尽力兼容各种浏览器，维持类似长连接（全双工）的服务。作为技术人员更多的注意的只是业务逻辑，在这套方案的基础上做开发即可。

sunuxreg 22楼•2年前

@sumory 应该是吧，如果支持WebSocket的话就会默认使用WebSocket，如果不支持的话会采用polling等方式，不是吗？

sumory 23楼•2年前

@sunuxreg 是这样的。但不能说是基于websocket的，它提供了很多协议，htmlfile、jsonp-polling、xhr-polling等，各个都是不同的。我记得socket.io的客户端版本在chrome和firefox上默认只能用websocket，要用其他的话，貌似要改源码，我是改了源码才用的。

sumory 24楼•2年前

@samoin

长连接!=全双工
长连接还是http1.1里的概念，只有websocket才是全双工
了解细节有助于出问题时去发现问题并解决

sunuxreg 25楼•2年前

@sumory 那请问clearInterval(intervalID); 是指在*Polling中才用的吗？WebSocket的时候还用吗？

halfblood 26楼•2年前

@sumory 不是在握手中，进行协议协商的时候，改变默认的ws协议就可以了吗？还要改动源码？长轮训等式为了兼容IE等不支持ws协议的浏览器而做的，应该是通用的，按理任何浏览器都会支持的吧。你怎么改动源码的？

sumory 27楼•2年前

@sunuxreg 都有用啊，这个只是在连接失败时重连接socket.socket.reconnect();

sumory 28楼•2年前

@halfblood 前端代码有判断浏览器，然后根据浏览器决定使用什么协议，我把那里改了。

halfblood 29楼•2年前

@sumory 长轮询的方式应该在性能等方面都会比ws差些吧，你是什么应用场景啊，需要改成长轮询的方式？

sumory 30楼•2年前

@halfblood 要兼容所有浏览器.所以直接把ws禁了，维护起来也方便.

samoin 31楼•2年前

@sumory 那你对时间参数的设置是如何的。比如"close timeout" , “heartbeat timeout” , “heartbeat interval” , “polling duration” 这些，默认的感觉对非ws协议的断开判断等1分钟太长了，又不敢设置得太小，我现在是取的一半的值。

sumory 32楼•2年前

@samoin 我也取了几十秒。你要根据你的业务来判断到底选什么时间合适啊。我到时觉得这些值的设置不是重点，1分钟也好，30秒也好。客户端方面关键是你中断的这段时间内，要友好的提示用户，并做好重连前的善后处理。服务端方面，做好连接断开后的对象处理，比如是否要删掉不可用的socket对象，业务数据是否要重置等等。

samoin 33楼•2年前

@sumory 嗯，友好提示很重要。请问你们上线前有对socket.io压力测试吗，如果有的话请问是用的什么工具。目前为止只是听说要自己弄机器人来压，具体不清楚是怎么是想的，还请指点迷经，谢谢。

sumory 34楼•2年前

@samoin 去年在github上找了一个websocket的库模拟压测过，不过那个很老了都不更新了。我们的应用规模不大，所以没做太多性能测试。

samoin 35楼•2年前

@sumory 哦，好的，谢谢啊

sumory 36楼•2年前

@samoin 哦，对了，腾讯朋友网有做过一个使用node.js做长连接的分享，那个里有性能测试。其实只是用长连接的话，你自己用node.js写也很容易的。

samoin 37楼•2年前

@sumory 哦，谢谢。我之前有听过pamelo的演讲，他们的框架通讯也基于socket.io，我看他说是800+的并发，机器人就是从他那听到的，但是不知道自己怎么弄，呵呵。嗯，之前在做页游的时候只是用flash来做通讯，现在公司的需求号称要兼容所有浏览器（感觉各种苦逼），就想到用socket.io来试试。现在考虑到在线并发的性能，所以想自己看看能支持多少。呵呵。

sumory 38楼•2年前

@samoin 我在我的普通虚机上测了下，前面加了一层nginx代理，测了下长连接的rps在500左右还能保持较高的响应速度。

samoin 39楼•2年前

@sumory 谢谢