节点 js 套接字说明

Node js socket explanation

本文关键字：说明 套接字 js 节点      更新时间：2023-09-26

我正在构建一个应用程序，该应用程序将对远程 api 服务器进行大约一百万次调用。我可以将连接数限制为例如 10 个吗？我是否将最大插槽设置为 10 可以吗？

我试图了解这些参数的作用：

keepAlive: false,
maxSockets: 999,
maxFreeSockets: 1

在节点 http get 函数中，在以下代码中：

var inputData = [];
for(i=1; i<=5000;i++){
    inputData.push('number' + i);
}
var options = {
    host: "localhost",
    port: 80,
    path: "/text.txt",
    keepAlive: false,
    maxSockets: 999,
    maxFreeSockets: 1
}

var limit = inputData.length;
var counter = 0;
function fetchData(number){
    return new Promise(function(resolve, reject){
        var http = require('http');
        fetch  = function(resp){
            var body = '';
            resp.on('data',function(chunk){
                body += chunk;
            })
            resp.on('end',function(){
                console.log(resp)
                resolve()
            })
            resp.on('error',function(err){
                console.log('error');
            })
        }
        var req = http.request(options, fetch);
        req.end();
    })
}

Promise.all(inputData.map(number => fetchData(number))).then(function(results) {
    console.log('finished');
    connection.end();
})
.catch(function(error) {
    console.log('there wa an error');
    console.log(error);
});

你真的不想触发 1，000，000 个请求，并以某种方式希望 maxSockets 一次管理到 100 个请求。 有很多原因说明这不是做事的好方法。 相反，您应该使用自己的代码来管理一次 100 个实时连接数。

有许多方法可以做到这一点：

  1. 编写自己的代码，触发 100，然后每次完成时，它都会触发下一个。

  2. 使用Bluebird的Promise.map()，它具有内置的并发功能，可以管理同时有多少个

    3. 飞行中。

  3. 使用 Async 的 async.mapLimit()，它具有内置的并发功能，可以管理同时有多少个正在飞行中。

至于自己编写代码来做到这一点，你可以做这样的事情;

function fetchAll() {
    var start = 1;
    var end = 1000000;
    var concurrentMax = 100;
    var concurrentCnt = 0;
    var cntr = start;
    return new Promise(function(resolve, reject) {
        // start up requests until the max concurrent requests are going
        function run() {
            while (cntr < end && concurrentCnt < concurrentMax) {
                ++concurrentCnt;
                fetchData(cntr++).then(function() {
                    --concurrentCnt;
                    run();
                }, function(err) {
                    --concurrentCnt;
                    // decide what to do with error here
                    // to continue processing more requests, call run() here
                    // to stop processing more requests, call reject(err) here
                });
            }
            if (cntr >= end && concurrentCnt === 0) {
                // all requests are done here
                resolve();
            }        
        }
        run();
    });
}

我决定使用异步库。

这是我对此的完整解决方案：

var async = require('async')
var http = require('http');
var inputData = [];
for(i=1; i<=2000;i++){
    inputData.push('number' + i);
}
var options = {
    host: "o2.pl",
    path: "/static/desktop.css?v=0.0.417",
    port: 80
}
function fetchData(number, callback){
    return new Promise(function(resolve, reject){
        fetch  = function(resp){
            var body = '';
            resp.on('data',function(chunk){
                body += chunk;
            })
            process.stdout.write('.')
            callback()
            resp.on('error',function(err){
                console.log('error');
                console.log(err);
            })
        }
        var req = http.request(options, fetch);
        req.end();
    })
}
function foo(item, callback){
    return callback(false, 'foo');
}
async.mapLimit(inputData,100,fetchData,function(err, result){
    console.log('finished');
})

谢谢你的帮助。

相关文章：