Eine eingehende Analyse der Rückrufwarteschlange von Node.js

Queue ist eine wichtige Technologie in Node.js für die effiziente Abwicklung asynchroner Vorgänge. [Video-Tutorial-Empfehlung: node js-Tutorial ]

In diesem Artikel werden wir uns eingehend mit Warteschlangen in Node.js befassen: was sie sind, wie sie funktionieren (über Ereignisschleifen) und ihre Typen.

Was ist eine Warteschlange in Node.js?

Queue ist eine Datenstruktur, die in Node.js zum Organisieren asynchroner Vorgänge verwendet wird. Diese Vorgänge gibt es in verschiedenen Formen, einschließlich HTTP-Anfragen, Lese- oder Schreiboperationen für Dateien, Streams usw.

Die Handhabung asynchroner Vorgänge in Node.js ist eine große Herausforderung.

Abhängig von der Netzwerkqualität kann es bei HTTP-Anfragen zu unvorhersehbaren Verzögerungen (oder, schlimmer noch, zu keinen Ergebnissen) kommen. Auch beim Versuch, Dateien mit Node.js zu lesen und zu schreiben, kann es je nach Größe der Datei zu Verzögerungen kommen.

Ähnlich wie bei Timern und vielen anderen Vorgängen kann auch die Abschlusszeit asynchroner Vorgänge ungewiss sein.

Angesichts dieser unterschiedlichen Latenzszenarien muss Node.js in der Lage sein, alle diese Vorgänge effizient abzuwickeln.

Node.js kann keine Vorgänge verarbeiten, die auf „First-Start-First-Handle“ (First-Start-First-Handle) oder „First-Finish-First-Handle“ (First-Finish-First-Handle) basieren.

Ein Grund, warum dies nicht möglich ist, besteht darin, dass eine asynchrone Operation auch eine andere asynchrone Operation enthalten kann.

Platz für den ersten asynchronen Prozess zu schaffen bedeutet, dass der innere asynchrone Prozess abgeschlossen werden muss, bevor andere asynchrone Vorgänge in der Warteschlange berücksichtigt werden können.

Es gibt viele Situationen, die es zu berücksichtigen gilt. Deshalb ist es am besten, Regeln aufzustellen. Diese Regel beeinflusst die Funktionsweise von Ereignisschleifen und Warteschlangen in Node.js.

Werfen wir einen kurzen Blick darauf, wie Node.js mit asynchronen Vorgängen umgeht.

Aufrufstapel, Ereignisschleife und Rückrufwarteschlange

Der Aufrufstapel wird verwendet, um den Überblick über die aktuell ausgeführte Funktion und den Ort zu behalten, an dem sie ausgeführt wurde. Wenn eine Funktion ausgeführt werden soll, wird sie dem Aufrufstapel hinzugefügt. Dies hilft JavaScript, seine Verarbeitungsschritte nach der Ausführung einer Funktion nachzuvollziehen.

Die Rückrufwarteschlange ist eine Warteschlange, die die Rückruffunktion als asynchrone Operation speichert, wenn die Hintergrundoperation abgeschlossen ist. Sie arbeiten nach dem First-In-First-Out-Prinzip (FIFO). Wir werden später in diesem Artikel verschiedene Arten von Rückrufwarteschlangen vorstellen.

Bitte beachten Sie, dass Node.js für alle asynchronen Aktivitäten verantwortlich ist, da JavaScript seine Single-Threaded-Natur ausnutzen kann, um zu verhindern, dass neue Threads erzeugt werden.

Nach Abschluss des Hintergrundvorgangs ist es auch für das Hinzufügen von Funktionen zur Rückrufwarteschlange verantwortlich. JavaScript selbst hat nichts mit Rückrufwarteschlangen zu tun. Gleichzeitig prüft die Ereignisschleife kontinuierlich, ob der Aufrufstapel leer ist, sodass eine Funktion aus der Rückrufwarteschlange extrahiert und dem Aufrufstapel hinzugefügt werden kann. Die Ereignisschleife überprüft die Warteschlange erst, nachdem alle Synchronisierungsvorgänge durchgeführt wurden.

In welcher Reihenfolge wählt die Ereignisschleife also Rückruffunktionen aus der Warteschlange aus?

Schauen wir uns zunächst die fünf Haupttypen von Rückrufwarteschlangen an.

Arten von Rückrufwarteschlangen

IO-Warteschlange (IO-Warteschlange)

IO-Vorgänge beziehen sich auf Vorgänge mit externen Geräten (z. B. Computerfestplatte, Netzwerkkarte usw.). Zu den allgemeinen Vorgängen gehören das Lesen und Schreiben von Dateivorgängen, Netzwerkvorgänge usw. Diese Vorgänge sollten asynchron sein, da ihre Verarbeitung Node.js überlassen bleibt.

JavaScript kann nicht auf die internen Geräte Ihres Computers zugreifen. Wenn ein solcher Vorgang ausgeführt wird, überträgt JavaScript ihn zur Verarbeitung im Hintergrund an Node.js.

Nach Abschluss werden sie in die E/A-Rückrufwarteschlange übertragen, damit die Ereignisschleife zur Ausführung an den Aufrufstapel übertragen wird.

Timer-Warteschlange

Jeder Vorgang, an dem die Node.js-Timer-Funktion beteiligt ist (z. B. setTimeout() und setInterval()), wird zur Timer-Warteschlange hinzugefügt . setTimeout() 和 setInterval()）都是要被添加到计时器队列的。

请注意，JavaScript 语言本身没有计时器功能。它使用 Node.js 提供的计时器 API（包括 setTimeout ）执行与时间相关的操作。所以计时器操作是异步的。无论是 2 秒还是 0 秒，JavaScript 都会把与时间相关的操作移交给 Node.js，然后将其完成并添加到计时器队列中。

例如：

setTimeout(function() {
        console.log('setTimeout');
    }, 0)
    console.log('yeah')


# 返回
yeah
setTimeout

在处理异步操作时，JavaScript 会继续执行其他操作。只有在所有同步操作都已被处理完毕后，事件循环才会进入回调队列。

微任务队列（Microtask queue）

该队列分为两个队列：

• 第一个队列包含因 process.nextTick
Bitte beachten Sie, dass JavaScript-Sprache selbst Keine Timerfunktion

. Es verwendet die von Node.js bereitgestellte Timer-API (einschließlich setTimeout ), um zeitbezogene Vorgänge auszuführen. Der Timerbetrieb ist also asynchron. Unabhängig davon, ob es sich um 2 Sekunden oder 0 Sekunden handelt, übergibt JavaScript den zeitbezogenen Vorgang an Node.js, das ihn dann abschließt und zur Timer-Warteschlange hinzufügt.

Zum Beispiel: 🎜

let prom = new Promise(function (resolve, reject) {
        // 延迟执行
        setTimeout(function () {
            return resolve("hello");
        }, 2000);
    });
    console.log(prom);
    // Promise { <pending> }
    
    prom.then(function (response) {
        console.log(response);
    });
    // 在 2000ms 之后,输出
    // hello

🎜Während der Verarbeitung eines asynchronen Vorgangs führt JavaScript weiterhin andere Vorgänge aus. Erst nachdem alle Synchronisationsvorgänge verarbeitet wurden, gelangt die Ereignisschleife in die Rückrufwarteschlange. 🎜

Mikrotask-Warteschlange (Microtask-Warteschlange) 🎜🎜Die Warteschlange ist in zwei Warteschlangen unterteilt: 🎜

• Die erste Warteschlange enthält process.nextTick< /code> Funktion und verzögerte Funktion. 🎜🎜🎜Jede von der Ereignisschleife ausgeführte Iteration wird als Tick (Zeitskala) bezeichnet. 🎜<p><code>process.nextTick 是一个函数，它在下一个 tick （即事件循环的下一个迭代）执行一个函数。微任务队列需要存储此类函数，以便可以在下一个 tick 执行它们。

  这意味着事件循环必须继续检查微任务队列中的此类函数，然后再进入其他队列。

  • 第二个队列包含因 promises 而延迟的函数。

  如你所见，在 IO 和计时器队列中，所有与异步操作有关的内容都被移交给了异步函数。

  但是 promise 不同。在 promise 中，初始变量存储在 JavaScript 内存中（你可能已经注意到了<Pending>）。

  异步操作完成后，Node.js 会将函数（附加到 Promise）放在微任务队列中。同时它用得到的结果来更新 JavaScript 内存中的变量，以使该函数不与 <Pending> 一起运行。

  以下代码说明了 promise 是如何工作的：

  let prom = new Promise(function (resolve, reject) {
          // 延迟执行
          setTimeout(function () {
              return resolve("hello");
          }, 2000);
      });
      console.log(prom);
      // Promise { <pending> }
      
      prom.then(function (response) {
          console.log(response);
      });
      // 在 2000ms 之后,输出
      // hello

  关于微任务队列，需要注意一个重要功能，事件循环在进入其他队列之前要反复检查并执行微任务队列中的函数。例如，当微任务队列完成时，或者说计时器操作执行了 Promise 操作，事件循环将会在继续进入计时器队列中的其他函数之前参与该 Promise 操作。

  因此，微任务队列比其他队列具有最高的优先级。

  检查队列（Check queue）

  检查队列也称为即时队列（immediate queue）。IO 队列中的所有回调函数均已执行完毕后，立即执行此队列中的回调函数。setImmediate 用于向该队列添加函数。

  例如：

  const fs = require('fs');
  setImmediate(function() {
      console.log('setImmediate');
  })
  // 假设此操作需要 1ms
  fs.readFile('path-to-file', function() {
      console.log('readFile')
  })
  // 假设此操作需要 3ms
  do...while...

  执行该程序时，Node.js 把 setImmediate 回调函数添加到检查队列。由于整个程序尚未准备完毕，因此事件循环不会检查任何队列。

  因为 readFile 操作是异步的，所以会移交给 Node.js，之后程序将会继续执行。

  do while 操作持续 3ms。在这段时间内，readFile 操作完成并被推送到 IO 队列。完成此操作后，事件循环将会开始检查队列。

  尽管首先填充了检查队列，但只有在 IO 队列为空之后才考虑使用它。所以在 setImmediate 之前，将 readFile 输出到控制台。

  关闭队列（Close queue）

  此队列存储与关闭事件操作关联的函数。

  包括以下内容：

  • 流关闭事件，在关闭流时发出。它表示不再发出任何事件。
  • http关闭事件，在服务器关闭时发出。

  这些队列被认为是优先级最低的，因为此处的操作会在以后发生。

  你肯sing不希望在处理 promise 函数之前在 close 事件中执行回调函数。当服务器已经关闭时，promise 函数会做些什么呢？

  队列顺序

  微任务队列具有最高优先级，其次是计时器队列，I/O队列，检查队列，最后是关闭队列。

  回调队列的例子

  让我们通过一个更复杂的例子来说明队列的类型和顺序：

  const fs = require("fs");
  
  // 假设此操作需要 2ms
  fs.writeFile('./new-file.json', '...', function() {
      console.log('writeFile')
  })
  
  // 假设这需要 10ms 才能完成 
  fs.readFile("./file.json", function(err, data) {
      console.log("readFile");
  });
  
  // 不需要假设，这实际上需要 1ms
  setTimeout(function() {
      console.log("setTimeout");
  }, 1000);
  
  // 假设此操作需要 3ms
  while(...) {
      ...
  }
  
  setImmediate(function() {
      console.log("setImmediate");
  });
  
  // 解决 promise 需要 4 ms
  let promise = new Promise(function (resolve, reject) {
      setTimeout(function () {
          return resolve("promise");
      }, 4000);
  });
  promise.then(function(response) {
      console.log(response)
  })
  
  console.log("last line");

  程序流程如下：

  • 在 0 毫秒时，程序开始。
  • 在 Node.js 将回调函数添加到 IO 队列之前，fs.writeFile 在后台花费 2 毫秒。

  fs.readFile takes 10ms at the background before Node.js adds the callback function to the IO queue.

  • 在 Node.js 将回调函数添加到 IO 队列之前，fs.readFile 在后台花费 10 毫秒。
  • 在 Node.js 将回调函数添加到计时器队列之前，setTimeout 在后台花费 1ms。
  • 现在，while 操作（同步）需要 3ms。在此期间，线程被阻止（请记住 JavaScript 是单线程的）。
  • 同样在这段时间内，setTimeout 和 fs.writeFile 操作完成，并将它们的回调函数分别添加到计时器和 IO 队列中。

  现在的队列是：

  // queues
  Timer = [
      function () {
          console.log("setTimeout");
      },
  ];
  IO = [
      function () {
          console.log("writeFile");
      },
  ];

  setImmediate 将回调函数添加到 Check 队列中：

  js
  // 队列
  Timer...
  IO...
  Check = [
      function() {console.log("setImmediate")}
  ]

  在将 promise 操作添加到微任务队列之前，需要花费 4ms 的时间在后台进行解析。

  最后一行是同步的，因此将会立即执行：

  # 返回
  "last line"

  因为所有同步活动都已完成，所以事件循环开始检查队列。由于微任务队列为空，因此它从计时器队列开始：

  // 队列
  Timer = [] // 现在是空的
  IO...
  Check...
  
  
  # 返回
  "last line"
  "setTimeout"

  当事件循环继续执行队列中的回调函数时，promise 操作完成并被添加到微任务队列中：

  // 队列
      Timer = [];
      Microtask = [
          function (response) {
              console.log(response);
          },
      ];
      IO = []; // 当前是空的
      Check = []; // 当前是在 IO 的后面，为空
  
  
      # results
      "last line"
      "setTimeout"
      "writeFile"
      "setImmediate"

  几秒钟后，readFile 操作完成，并添加到 IO 队列中：

  // 队列
      Timer = [];
      Microtask = []; // 当前是空的
      IO = [
          function () {
              console.log("readFile");
          },
      ];
      Check = [];
  
  
      # results
      "last line"
      "setTimeout"
      "writeFile"
      "setImmediate"
      "promise"

  最后，执行所有回调函数：

  // 队列
      Timer = []
      Microtask = []
      IO = [] // 现在又是空的
      Check = [];
  
  
      # results
      "last line"
      "setTimeout"
      "writeFile"
      "setImmediate"
      "promise"
      "readFile"

  这里要注意的三点：

  • 异步操作取决于添加到队列之前的延迟时间。并不取决于它们在程序中的存放顺序。
  • 事件循环在每次迭代之继续检查其他任务之前，会连续检查微任务队列。
  • 即使在后台有另一个 IO 操作（readFile），事件循环也会执行检查队列中的函数。这样做的原因是此时 IO 队列为空。请记住，在执行 IO 队列中的所有的函数之后，将会立即运行检查队列回调。

  总结

  JavaScript 是单线程的。每个异步函数都由依赖操作系统内部函数工作的 Node.js 去处理。

  Node.js 负责将回调函数（通过 JavaScript 附加到异步操作）添加到回调队列中。事件循环会确定将要在每次迭代中接下来要执行的回调函数。

  了解队列如何在 Node.js 中工作，使你对其有了更好的了解，因为队列是环境的核心功能之一。 Node.js 最受欢迎的定义是 non-blocking（非阻塞），这意味着异步操作可以被正确的处理。都是因为有了事件循环和回调队列才能使此功能生效。

  更多编程相关知识，可访问：编程教学！！
  

  Das obige ist der detaillierte Inhalt vonEine eingehende Analyse der Rückrufwarteschlange von Node.js. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!