setImmediate vs nextTick

Utilisation setImmediate si vous voulez la file d'attente de la fonction derrière tout ce I/O rappels d'événements qui sont déjà dans la file d'attente des événements. Utilisation process.nextTick efficacement la file d'attente de la fonction à la tête de la file d'attente d'événements, de sorte qu'il s'exécute immédiatement après la fonction en cours est terminée.

Donc, dans le cas où vous essayez de briser une longue course, le CPU de l'emploi à l'aide de la récursivité, vous souhaitez désormais utiliser setImmediate plutôt que process.nextTick à la file d'attente de la prochaine itération que sinon, n'importe quel événement I/O rappels n'aurais pas la chance de courir entre les itérations.

Je pense que je peut illustrer cela tout à fait bien. Depuis nextTick est appelé à la fin de l'opération en cours, en l'appelant récursivement peut finir par bloquer la boucle d'événement de continuer. setImmediate résout ce problème en tirant dans la phase de vérification de la boucle d'événements, permettant la boucle d'événement de continuer normalement.

   ┌───────────────────────┐
┌─>│        timers         │
│  └──────────┬────────────┘
│  ┌──────────┴────────────┐
│  │     I/O callbacks     │
│  └──────────┬────────────┘
│  ┌──────────┴────────────┐
│  │     idle, prepare     │
│  └──────────┬────────────┘      ┌───────────────┐
│  ┌──────────┴────────────┐      │   incoming:   │
│  │         poll          │<─────┤  connections, │
│  └──────────┬────────────┘      │   data, etc.  │
│  ┌──────────┴────────────┐      └───────────────┘
│  │        check          │
│  └──────────┬────────────┘
│  ┌──────────┴────────────┐
└──┤    close callbacks    │
   └───────────────────────┘

source: https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/

Avis que la phase de vérification est immédiatement après le sondage la phase. C'est parce que le sondage la phase d'e/S et les rappels sont les plus susceptibles des lieux de vos appels à setImmediate allez courir. Idéalement, la plupart de ces appels seront effectivement assez immédiate, n'est pas aussi immédiat que nextTick qui est vérifiée après chaque opération, et techniquement existe en dehors de la boucle d'événements.

Prenons un coup d'oeil à un petit exemple de la différence entre setImmediate et process.nextTick:

function step(iteration) {
  if (iteration === 10) return;
  setImmediate(() => {
    console.log(`setImmediate iteration: ${iteration}`);
    step(iteration + 1); //Recursive call from setImmediate handler.
  });
  process.nextTick(() => {
    console.log(`nextTick iteration: ${iteration}`);
  });
}
step(0);

Disons-nous juste couru ce programme et avancerez dans la première itération de la boucle d'événements. Il va appeler dans le step fonction à l'itération zéro. Il enregistre alors deux fonctions, une pour setImmediate et un pour process.nextTick. Nous avons ensuite récursivement appeler cette fonction à partir de la setImmediate gestionnaire qui sera exécuté dans la prochaine phase de vérification. Le nextTick gestionnaire d'exécuter à la fin de l'opération en cours d'interrompre la boucle d'événements, de sorte que même si elle a été enregistrée en deuxième, il sera effectivement exécuté en premier.

L'ordre finit par être: nextTick feux comme l'opération en cours se termine, à côté de l'événement de la boucle commence, normal de la boucle d'événement de phases d'exécution, setImmediate incendies et appelle de manière récursive notre step fonction pour commencer le processus une fois de plus. Opération en cours se termine, nextTick feux, etc.

La sortie du code ci-dessus serait:

nextTick iteration: 0
setImmediate iteration: 0
nextTick iteration: 1
setImmediate iteration: 1
nextTick iteration: 2
setImmediate iteration: 2
nextTick iteration: 3
setImmediate iteration: 3
nextTick iteration: 4
setImmediate iteration: 4
nextTick iteration: 5
setImmediate iteration: 5
nextTick iteration: 6
setImmediate iteration: 6
nextTick iteration: 7
setImmediate iteration: 7
nextTick iteration: 8
setImmediate iteration: 8
nextTick iteration: 9
setImmediate iteration: 9

Maintenant, nous allons passer notre appel récursif à step dans notre nextTick gestionnaire de la place de la setImmediate.

function step(iteration) {
  if (iteration === 10) return;
  setImmediate(() => {
    console.log(`setImmediate iteration: ${iteration}`);
  });
  process.nextTick(() => {
    console.log(`nextTick iteration: ${iteration}`);
    step(iteration + 1); //Recursive call from nextTick handler.
  });
}
step(0);

Maintenant que nous sommes passés de l'appel récursif de step dans le nextTick gestionnaire choses vont se comporter dans un ordre différent. Notre première itération de la boucle d'événement de courses et les appels step l'enregistrement d'un setImmedaite gestionnaire ainsi que d'un nextTick gestionnaire. Après l'opération en cours se termine notre nextTick gestionnaire d'incendies, qui appelle de manière récursive step et enregistre une autre setImmediate gestionnaire ainsi qu'un autre nextTick gestionnaire. Depuis un nextTick gestionnaire d'incendies après l'opération en cours, l'enregistrement d'un nextTick de gestionnaire au sein d'une nextTick gestionnaire sera la cause de la deuxième gestionnaire d'exécuter immédiatement après l'actuel gestionnaire opération se termine. Le nextTick gestionnaires va continuer à tirer, la prévention de l'événement courant en boucle continue. Nous allons passer à travers tous nos nextTick gestionnaires avant de nous voir une seule setImmediate gestionnaire d'incendie.

La sortie du code ci-dessus, finit par être:

nextTick iteration: 0
nextTick iteration: 1
nextTick iteration: 2
nextTick iteration: 3
nextTick iteration: 4
nextTick iteration: 5
nextTick iteration: 6
nextTick iteration: 7
nextTick iteration: 8
nextTick iteration: 9
setImmediate iteration: 0
setImmediate iteration: 1
setImmediate iteration: 2
setImmediate iteration: 3
setImmediate iteration: 4
setImmediate iteration: 5
setImmediate iteration: 6
setImmediate iteration: 7
setImmediate iteration: 8
setImmediate iteration: 9

Noter que si on l'avait pas interrompu l'appel récursif et abandonnée après 10 itérations puis le nextTick appels garder recursing et de ne jamais laisser la boucle d'événement de continuer à la prochaine phase. C'est de cette façon nextTick peuvent devenir de blocage lorsqu'elle est utilisée de manière récursive alors que setImmediate le feu dans la prochaine boucle d'événement et de fixer une autre setImmediate gestionnaire de l'intérieur d'une de ne pas interrompre le courant de boucle d'événements, ce qui permet de continuer à exécuter les phases de la boucle d'événements comme normal.

Espère que ça aide!

PS - je suis d'accord avec les autres commentateurs, les noms de ces deux fonctions pourraient facilement être échangé depuis nextTick l'impression que ça va pour mettre le feu dans la prochaine boucle d'événement plutôt qu'à la fin de celui en cours, et à la fin de la boucle de courant est plus "immédiat" que le début de la boucle suivante. Eh bien, c'est ce que nous obtenons comme une API évolue et que les gens viennent à dépendre des interfaces existantes.

En termes simples, le processus.NextTick() serait exécuté à la prochaine case de boucle d'événements. Cependant, la setImmediate, a essentiellement une phase distincte qui assure que le rappel enregistré sous setImmediate() sera appelée qu'après les IO de rappel et le sondage la phase.

Veuillez consulter ce lien pour belle explication:
https://medium.com/the-node-js-collection/what-you-should-know-to-really-understand-the-node-js-event-loop-and-its-metrics-c4907b19da4c

Je vous recommande de vérifier docs section dédiée Boucle for pour obtenir une meilleure compréhension. Quelques extrait à partir de là:

Nous avons deux appels qui sont similaires en ce qui concerne les utilisateurs, mais leurs noms sont source de confusion.

• processus.nextTick() se déclenche immédiatement sur la même phase

• setImmediate() déclenche l'itération suivante ou "tick" de l'
  
  boucle d'événement de

En essence, les noms doivent être inversés. processus.nextTick() feux plus immédiatement que setImmediate(), mais c'est un artefact du passé qui est peu susceptible de changer.