Est prise séquentielle des requêtes HTTP d'une opération de blocage dans le nœud?

Normalement, I/O dans node.js sont non-bloquant. Vous pouvez tester cela en faisant plusieurs demandes simultanément à votre serveur. Par exemple, si la demande prend 1 seconde, un blocage serveur serait de prendre 2 secondes à 2 demandes simultanées, mais un non-blocage du serveur serait de prendre un peu plus de 1 seconde pour traiter les demandes.

Cependant, vous pouvez délibérément faire des demandes de blocage à l'aide de la sync-demande module au lieu de demande. Évidemment, ce n'est pas recommandé pour les serveurs.

Voici un peu de code pour illustrer la différence entre le blocage et les non-blocage I/O:

var req = require('request');
var sync = require('sync-request');

//Load example.com N times (yes, it's a real website):
var N = 10;

console.log('BLOCKING test ==========');
var start = new Date().valueOf();
for (var i=0;i<N;i++) {
    var res = sync('GET','http://www.example.com')
    console.log('Downloaded ' + res.getBody().length + ' bytes');
}
var end = new Date().valueOf();
console.log('Total time: ' + (end-start) + 'ms');

console.log('NON-BLOCKING test ======');
var loaded = 0;
var start = new Date().valueOf();
for (var i=0;i<N;i++) {
    req('http://www.example.com',function( err, response, body ) {
        loaded++;
        console.log('Downloaded ' + body.length + ' bytes');
        if (loaded == N) {
            var end = new Date().valueOf();
            console.log('Total time: ' + (end-start) + 'ms');
        }
    })
}

L'exécution du code ci-dessus, vous verrez le non-blocage de test prend à peu près la même quantité de temps pour traiter toutes les demandes que pour une seule requête (par exemple, si vous définissez N = 10, la non-bloquante code s'exécute 10 fois plus rapide que le blocage de code). Cela illustre clairement que la demande est non-bloquant.

Réponse supplémentaire:

Vous avez également mentionné que vous êtes inquiet au sujet de votre processus de l'UC. Mais dans votre code, vous n'êtes pas d'analyse comparative de l'UC de l'utilitaire. Vous êtes à la mélangeant à la fois le réseau demande du temps (I/O, qui, nous le savons, est non-bloquant) et le PROCESSEUR de la durée des processus. Pour mesurer combien de temps la demande est en mode de blocage de changement de votre code:

async.waterfall([
    function(cb) {
        request(someUrl1, function(err, res, body) {
            console.time('1');
            //load and parse the given web page.
            console.timeEnd('1');
            //make a callback with data parsed from the web page
        });
    },
    function(someParameters, cb) {
        request({url: someUrl2, method: 'POST', form: {/* data */}}, function(err, res, body) {
            console.time('2');
            //more computation
            console.timeEnd('2');

            //make a callback with a session cookie given by the visited url
        });
    },
    function(jar, cb) {
        request({url: someUrl3, method: 'GET', jar: jar /* cookie from the previous callback */}, function(err, res, body) {
            console.time('3');
            //do more parsing + computation
            console.timeEnd('3');
            //make another callback with the results
        });
    },
    function(moreParameters, cb) {
        request({url: someUrl4, method: 'POST', jar: jar, form : {/*data*/}}, function(err, res, body) {
            console.time('4');
            //some more computation.
            console.timeEnd('4');

            //make final callback
        });
    }
], function (err, result) {
    res.status(200).send();
});

Votre code bloque seulement dans le "plus de calcul" des pièces. De sorte que vous pouvez ignorer complètement le temps d'attente pour les autres parties à exécuter. En fait, c'est exactement la façon dont nœud peut servir à de multiples demandes simultanément. En attendant les autres parties à l'appel de l'respectives rappels (vous mentionner qu'il peut prendre jusqu'à 1 seconde) nœud peut exécuter du code javascript et poignée d'autres requêtes.

OriginalL'auteur slebetman

Vous pouvez utiliser la file d'attente de processus simultanés http appels en nodeJs
https://www.npmjs.com/package/concurrent-queue

    var cq = require('concurrent-queue');
    test_queue = cq();

    //request action method
    testQueue: function(req, res) {
        //queuing each request to process sequentially
        test_queue(req.user, function (err, user) {
            console.log(user.id+' done');
            res.json(200, user)
        });
    },


    //Queue will be processed one by one.
    test_queue.limit({ concurrency: 1 }).process(function (user, cb) {
        console.log(user.id + ' started')

        //async calls will go there
        setTimeout(function () {
            //on callback of async, call cb and return response.
            cb(null, user)
        }, 1000);

    });

Rappelez-vous qu'il doit mettre en œuvre pour les sensibles, les appels d'entreprise où la ressource qui doit être accessible ou mise à jour à un moment par un seul utilisateur.

Cela va bloquer votre I/O et de faire vos utilisateurs à attendre et le temps de réponse sera lente.

Optimisation:

Vous pouvez le faire plus rapidement et d'optimiser la création de ressources dépendant de la file d'attente. Afin qu'il y ait une file d'attente séparée pour chaque ressource partagée et synchrone appels pour une même ressource ne peut être exécutée que pour une même ressource pour les différentes ressources les appels seront exécutées de manière asynchrone

Supposons que vous souhaitez mettre en œuvre que sur la base de l'utilisateur actuel. De sorte que, pour le même utilisateur http appels ne peuvent exécuter de façon synchrone et pour les différents utilisateurs https appels seront asynchrone

testQueue: function(req, res) {

    //if queue not exist for current user.
    if(! (test_queue.hasOwnProperty(req.user.id)) ){
        //initialize queue for current user
        test_queue[req.user.id] = cq();
        //initialize queue processing for current user
        //Queue will be processed one by one.
        test_queue[req.user.id].limit({ concurrency: 1 }).process(function (task, cb) {
            console.log(task.id + ' started')
            //async functionality will go there
            setTimeout(function () {
                cb(null, task)
            }, 1000)
        });
    }

    //queuing each request in user specific queue to process sequentially
    test_queue[req.user.id](req.user, function (err, user) {
        if(err){
            return;
        }
        res.json(200, user)
        console.log(user.id+' done');
    });
},

Ce sera rapide et bloc d'e/S que pour la ressource pour laquelle vous souhaitez.

OriginalL'auteur Ibtesam Latif