Comprendre les événements et la boucle d'événements dans nodejs

Recommandations associées : "tutoriel nodejs"

Les amis qui connaissent javascript auraient dû utiliser des événements, tels que le mouvement de la souris, le clic de la souris, Saisie au clavier et ainsi de suite. Nous écoutons ces événements en javascript pour déclencher le traitement correspondant.

Il y a aussi des événements dans le même nodejs, et il existe également un module d'événements spéciaux pour un traitement spécialisé.

Les événements simultanés et les boucles d'événements sont également des concepts très importants pour créer des IO asynchrones dans nodejs.

Aujourd’hui, nous en apprendrons davantage.

Événements

nodejs fournit un module spécial pour les événements : lib/events.js.

Vous vous souvenez quand nous parlions de l'utilisation de nodejs pour créer un serveur Web ?

const server = http.createServer((req, res) => {
  res.statusCode = 200
  res.setHeader('Content-Type', 'text/plain')
  res.end('welcome to www.flydean.com\n')
})

Ici, chaque requête déclenchera l'événement de requête.

L'API principale de nodejs est basée sur une architecture asynchrone basée sur les événements, il y a donc beaucoup d'événements dans nodejs.

Par exemple : net.Server déclenchera un événement à chaque nouvelle connexion, fs.ReadStream déclenchera un événement à l'ouverture d'un fichier et stream déclenchera un événement lorsque les données seront lisibles.

Voyons comment créer un événement nodejs :

const EventEmitter = require('events')
const eventEmitter = new EventEmitter()

Il existe deux méthodes couramment utilisées pour les événements, à savoir on et submit.

on est utilisé pour écouter les événements, et émettre est utilisé pour déclencher des événements.

eventEmitter.on('fire', () => {
  console.log('开火')
})

eventEmitter.emit('fire')

emit peut également prendre des paramètres. Jetons un coup d'œil au paramètre suivant :

eventEmitter.on('fire', who => {
  console.log(`开火 ${who}`)
})

eventEmitter.emit('fire', '美帝')

Regardons les deux paramètres :

eventEmitter.on('fire', (who, when) => {
  console.log(`开火 ${who} ${when}`)
})

eventEmitter.emit('fire', '川建国'，'now')

Par défaut, EventEmitter commence par All. les auditeurs sont appelés de manière synchrone dans l’ordre dans lequel ils ont été enregistrés. Cela garantit un ordre correct des événements et permet d’éviter les conditions de concurrence et les erreurs logiques.

Si une exécution asynchrone est requise, vous pouvez utiliser setImmediate() ou process.nextTick() pour passer en mode d'exécution asynchrone.

eventEmitter.on('fire', (who, when) => {
    setImmediate(() => {
      console.log(`开火 ${who} ${when}`);
  });
})

eventEmitter.emit('fire', '川建国'，'now')

De plus, les événements prennent également en charge plusieurs autres méthodes :

once() : ajouter un écouteur unique

removeListener() / off() : supprimer l'événement auditeurs de l'événement

removeAllListeners() : Supprime tous les auditeurs de l'événement

Boucle d'événement

Nous savons que le code nodejs s'exécute dans un environnement monothread Oui, un seul la chose sera réglée à un moment donné.

Cette méthode de traitement évite le problème de synchronisation des données dans les environnements multithread et améliore considérablement l'efficacité du traitement.

La soi-disant boucle d'événements signifie que dans un cycle de programme, une fois que le processeur a traité les événements de ce cycle, il entrera dans le cycle d'événements suivant et traitera les affaires du cycle d'événements suivant. faire du vélo .

Blocage de la boucle d'événement

Si le traitement d'un événement est bloqué lors du traitement d'un événement, cela affectera l'exécution d'autres événements, on voit donc qu'en JS, presque toutes les IO sont non bloquant. C'est aussi pourquoi il y a tant de rappels en JavaScript.

Exemple de boucle d'événement

Regardons un exemple simple de boucle d'événement :

const action2 = () => console.log('action2')

const action3 = () => console.log('action3')

const action1 = () => {
    console.log('action1')
    action2()
    action3()
}

action1()

La sortie du code ci-dessus :

action1
action2
action3

Pile et file d'attente de messages

Nous savons que les appels entre fonctions sont implémentés via la pile.

Mais toutes les méthodes de la fonction ne seront pas placées sur la pile, et certaines méthodes seront placées dans la file d'attente des messages.

Donnons un autre exemple :

const action2 = () => console.log('action2')

const action3 = () => console.log('action3')

const action1 = () => {
    console.log('action1')
    setTimeout(action2, 0)
    action3()
}

action1()

Le résultat de l'exécution du code ci-dessus est :

action1
action3
action2

Le résultat est différent. En effet, settimeout déclenche le minuteur. Lorsque le minuteur expire, la fonction de rappel sera placée dans la file d'attente des messages pour être traitée au lieu d'être placée sur la pile.

La boucle d'événements donnera la priorité aux événements dans la pile. Ce n'est que lorsqu'il n'y aura aucune donnée dans la pile qu'elle passera à la consommation d'événements dans la file d'attente des messages.

Bien que le délai d'attente de setTimeout dans l'exemple ci-dessus soit de 0, il doit toujours attendre que l'action3 soit exécutée avant de pouvoir être exécuté.

Notez que le délai d'attente dans setTimeout n'attend pas dans le thread actuel. Il est appelé par le navigateur ou un autre environnement d'exécution JS.

File d'attente des tâches et promesse

La promesse dans ES6 introduit le concept de file d'attente des tâches qui exécutera le résultat de la fonction asynchrone dès que possible au lieu de le placer à la fin de l'appel. empiler.

Par exemple :

const action2 = () => console.log('action2')

const action3 = () => console.log('action3')

const action1 = () => {
    console.log('action1')
    setTimeout(action2, 0)
    new Promise((resolve, reject) =>
        resolve('应该在action3之后、action2之前')
    ).then(resolve => console.log(resolve))
    action3()
}

action1()

Résultat de sortie :

action1
action3
应该在action3之后、action2之前
action2

En effet, la promesse résolue avant la fin de la fonction actuelle sera exécutée immédiatement après la fonction actuelle.

C'est-à-dire que la pile est exécutée en premier, puis la file d'attente des tâches est exécutée et enfin la file d'attente des messages est exécutée.

process.nextTick()

Tout d'abord, permettez-moi de vous donner une définition appelée tick Un tick fait référence à un cycle d'événements. Process.nextTick() fait référence à l'appel de cette fonction avant le début du prochain tick de boucle d'événement :

process.nextTick(() => {
  console.log('i am the next tick');
})

Donc, nextTick doit être plus rapide que le setTimeout de la file d'attente des messages.

setImmediate()

nodejs fournit une méthode setImmediate pour exécuter du code le plus rapidement possible.

setImmediate(() => {
  console.log('I am immediate!');
})

La fonction dans setImmediate sera exécutée lors de la prochaine itération de la boucle d'événements.

Les fonctions de setImmediate() et setTimeout(() => {}, 0) sont fondamentalement similaires. Ils seront tous exécutés lors de la prochaine itération de la boucle d’événements.

setInterval()

Si vous souhaitez exécuter certaines fonctions de rappel régulièrement, vous devez utiliser setInterval.

setInterval(() => {
  console.log('每隔2秒执行一次');
}, 2000)

要清除上面的定时任务，可以使用clearInterval：

const id = setInterval(() => {
  console.log('每隔2秒执行一次');
}, 2000)

clearInterval(id)

注意，setInterval是每隔n毫秒启动一个函数，不管该函数是否执行完毕。

如果一个函数执行时间太长，就会导致下一个函数同时执行的情况，怎么解决这个问题呢？

我们可以考虑在回调函数内部再次调用setTimeout，这样形成递归的setTimeout调用：

const myFunction = () => {
  console.log('做完后，隔2s再次执行！');

  setTimeout(myFunction, 2000)
}

setTimeout(myFunction, 2000)

更多编程相关知识，请访问：编程视频！！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!