Comment dormir le fil dans node.js sans affecter les autres threads?

Comme par La compréhension de la node.js boucle d'événement, node.js prend en charge un seul modèle de thread. Cela signifie que si je fais plusieurs demandes pour un node.js serveur, il ne sera pas générer un nouveau thread pour chaque demande, mais seront exécutées à chaque demande, un par un. Cela signifie que si je ne les suivants: pour la première demande dans mon node.js code, et en attendant une nouvelle demande arrive sur le nœud, la deuxième demande doit attendre jusqu'à ce que la première demande complète, y compris de 5 secondes, le temps de sommeil. Droit?

var sleep = require('sleep');
    sleep.sleep(5)//sleep for 5 seconds

Est-il un moyen que node.js peut générer un nouveau thread pour chaque demande, de sorte que la deuxième demande de ne pas attendre la fin de la première demande de compléter, ou puis-je appeler le sommeil sur le thread spécifique seulement?

InformationsquelleAutor emilly | 2012-11-19
  1. 119

    Si vous faites référence à l'mnp module le sommeil, il note dans le fichier readme qui sleep va bloquer l'exécution. Donc, vous avez raison, ce n'est pas ce que vous voulez. Au lieu de cela vous voulez utiliser setTimeout qui est non-bloquante. Voici un exemple:

    setTimeout(function() {
  console.log('hello world!');
}, 5000);

    Pour ceux qui cherchent à le faire à l'aide de es7 async/await, cet exemple devrait vous aider:

    const snooze = ms => new Promise(resolve => setTimeout(resolve, ms));

const example = async () => {
  console.log('About to snooze without halting the event loop...');
  await snooze(1000);
  console.log('done!');
};

example();
    • donc node.js va exécuter une requête à la fois ce qui signifie qu'il suit à thread unique modèle. Droit?
    • Oui, il utilise un seul thread d'exécution de sorte qu'il ne peut être l'informatique une requête à la fois, mais pourrait avoir des événements en cours sur de nombreuses requêtes. Lorsque vous appelez setTimeout, il enregistre l'événement dans la file d'attente et peut commencer l'exécution de la prochaine demande. Après cinq secondes, l'événement sera supprimé de la file d'attente et le rappel sera exécuté (la fonction contenant console.log dans ce cas).
    • Jetez un oeil à cette vidéo pour un peu plus de détails sur la façon Node.js exécute plusieurs demandes sans les faire "attendre" les uns sur les autres.
    • De ne pas bloquer le thread. Code après cette setTimeout va continuer, puis console print 'bonjour le monde' au bout de 5 secondes.
    • Comment Nœud décide que setTimeout devrait être tiré à un certain moment, après le retrait de la file d'attente? En d'autres termes, ce qui déclenche la fonction à exécuter après cinq secondes si elle n'est pas en mode d'exécution/contexte?
    • Nœud de fonctionnement interne, en s'appuyant sur certains personnalisée JS/C++, une bibliothèque appelée libuv et libev etc. Il y a certains blogs/articles de discuter les détails de la FAÇON dont le Nœud qui fait que cela fonctionne. Mais ci-dessus est le comportement qui en résulte.
    • Donc tu veux dire que le sommeil est un faux sommeil? Juste une boucle occupée?
    • Ce paquet semble avoir un faible niveau v8 de liaison pour suspendre l'exécution sans une longue boucle, mais, conceptuellement, vous pouvez penser de cette façon. De toute façon, sleep n'est pas quelque chose qui devrait être dans le code de production, car il bloque l'exécution en simultané pendant qu'il s'exécute.

    InformationsquelleAutor David Weldon
  2. 2

    Dans le cas où vous avez une boucle avec une demande asynchrone dans chaque et vous voulez un certain temps entre chaque demande, vous pouvez utiliser ce code:

       var startTimeout = function(timeout, i){
        setTimeout(function() {
            myAsyncFunc(i).then(function(data){
                console.log(data);
            })
        }, timeout);
   }

   var myFunc = function(){
        timeout = 0;
        i = 0;
        while(i < 10){
            //By calling a function, the i-value is going to be 1.. 10 and not always 10
            startTimeout(timeout, i);
            //Increase timeout by 1 sec after each call
            timeout += 1000;
            i++;
        }
    }

    Ce exemples attend 1 seconde après chaque demande avant d'envoyer la suivante.

    • -1. C'est PAS allez faire quoi vous attendre. La boucle ne s'exécute de façon asynchrone. Il mettra le feu à toutes les demandes immédiatement. Soyez très prudent lorsque l'on pense en boucle avec async -- cette combinaison est délicate.
    • Bien sûr, la boucle est appelée une fois pour toutes. Mais le timout augmente à chaque boucle. Donc, 1 s... 2 sec ... 3 sec. C'est pourquoi "myAsyncFunc" sera appelée à chaque seconde, plutôt que tout à la fois. Il fonctionne comme prévu lorsque je teste ça. Pouvez-vous me dire ce que vous pensez est le problème avec elle?
    • Le code fonctionne, par la façon dont, dans un peu de façon délicate. Le startTimeout la fonction est appelé 10 fois immédiatement, mais chaque appel a un délai d'attente d'une seconde de plus grand, de sorte que chaque appel à myAsyncFunc, est appelé une seconde plus tard.
    • Mais cela va à l'encontre de l'objectif même de la boucle. Vous devriez être en mesure de décider combien de fois la boucle s'exécute. Ce que vous faites au-dessus d'exécuter la boucle exactement 10 fois -- peu importe si vous avez besoin de 10 itérations ou pas. Vous ne pouvez pas décider si vous voulez une autre itération ou pas à la fin de l'itération précédente -- parce que vous ne savez pas quand la fin de l'itération précédente produire. Par conséquent, vous devez décider à l'avance le nombre d'itérations de se produire. L'itération de casser la logique sera alors la fuite dans l'objet de rappel -- myAsyncFunc dans votre cas.
    • Le second défaut, c'est que vous êtes en supposant que que votre rappel va prendre pas plus de 1 seconde à exécuter. Que faire si votre prochaine itération dépendait de votre précédente itération du résultat, et ce résultat n'était pas garanti d'être disponible dans un délai de 1 seconde. Ensuite, votre prochaine itération va commencer sans les résultats, car il va commencer à exactement 1 seconde après l'itération précédente, ne prêtant aucune attention à ce que la fonction de rappel appelée à partir de l'itération précédente a effectivement conclu ou non.
    InformationsquelleAutor Jodo
  3. 1

    Veuillez prendre en compte les deasync module, personnellement je n'aime pas la Promesse façon de faire de toutes les fonctions asynchrones, et le mot-clé async/await anythere. Et je pense que l'officiel node.js devraient envisager d'exposer la boucle d'événements de l'API, cela permettra de résoudre le rappel de l'enfer, tout simplement. Node.js est un cadre pas une langue.

    var node = require("deasync");
node.loop = node.runLoopOnce;

var done = 0;
//async call here
db.query("select * from ticket", (error, results, fields)=>{
    done = 1;
});

while (!done)
    node.loop();

//Now, here you go
    InformationsquelleAutor Sunding Wei