Node.js의 콜백 큐에 대한 심층 분석

Queue는 비동기 작업을 효율적으로 처리하기 위한 Node.js의 중요한 기술입니다. [동영상 튜토리얼 권장 사항: node js tutorial ]

이 기사에서는 Node.js의 대기열이 무엇인지, 대기열이 어떻게 작동하는지(이벤트 루프를 통해) 및 유형에 대해 자세히 알아볼 것입니다.

Node.js의 대기열이란 무엇인가요?

Queue는 Node.js에서 비동기 작업을 구성하는 데 사용되는 데이터 구조입니다. 이러한 작업은 HTTP 요청, 파일 읽기 또는 쓰기 작업, 스트림 등을 포함하여 다양한 형태로 존재합니다.

Node.js에서 비동기 작업을 처리하는 것은 매우 어렵습니다.

네트워크 품질에 따라 HTTP 요청 중에 예측할 수 없는 지연(또는 더 나쁜 경우, 결과 없음)이 발생할 수 있습니다. 파일 크기에 따라 Node.js로 파일을 읽고 쓰려고 할 때 지연이 발생할 수도 있습니다.

타이머 및 기타 여러 작업과 마찬가지로 비동기 작업의 완료 시간도 불확실할 수 있습니다.

이러한 다양한 대기 시간 시나리오에서 Node.js는 이러한 모든 작업을 효율적으로 처리할 수 있어야 합니다.

Node.js는 첫 시작 첫 핸들(첫 시작 첫 핸들) 또는 첫 마무리 첫 핸들(첫 완료 첫 핸들)을 기반으로 하는 작업을 처리할 수 없습니다.

이 작업을 수행할 수 없는 이유 중 하나는 하나의 비동기 작업에 다른 비동기 작업이 포함될 수도 있다는 것입니다.

첫 번째 비동기 프로세스를 위한 공간을 만든다는 것은 대기열의 다른 비동기 작업을 고려하기 전에 내부 비동기 프로세스가 완료되어야 함을 의미합니다.

고려해야 할 상황이 많기 때문에 가장 좋은 선택은 규칙을 만드는 것입니다. 이 규칙은 Node.js에서 이벤트 루프와 큐가 작동하는 방식에 영향을 미칩니다.

Node.js가 비동기 작업을 처리하는 방법을 간략하게 살펴보겠습니다.

콜 스택, 이벤트 루프 및 콜백 큐

콜 스택은 현재 실행 중인 함수와 함수가 시작된 위치를 추적하는 데 사용됩니다. 함수가 실행되려고 하면 호출 스택에 추가됩니다. 이는 JavaScript가 함수 실행 후 처리 단계를 재추적하는 데 도움이 됩니다.

콜백 큐는 백그라운드 작업이 완료되면 콜백 함수를 비동기 작업으로 저장하는 큐입니다. FIFO(선입선출) 방식으로 작동합니다. 이 문서의 뒷부분에서 다양한 유형의 콜백 대기열을 소개하겠습니다.

JavaScript는 단일 스레드 특성을 활용하여 새 스레드가 생성되는 것을 방지할 수 있으므로 Node.js가 모든 비동기 활동을 담당한다는 점에 유의하세요.

백그라운드 작업을 완료한 후 콜백 대기열에 기능을 추가하는 역할도 담당합니다. JavaScript 자체는 콜백 대기열과 아무 관련이 없습니다. 동시에 이벤트 루프는 콜백 큐에서 함수를 추출하여 콜 스택에 추가할 수 있도록 콜 스택이 비어 있는지 지속적으로 확인합니다. 이벤트 루프는 모든 동기화 작업이 수행된 후에만 큐를 확인합니다.

그렇다면 이벤트 루프는 어떤 순서로 대기열에서 콜백 함수를 선택합니까?

먼저 5가지 주요 콜백 대기열 유형을 살펴보겠습니다.

콜백 큐의 종류

IO 큐(IO 큐)

IO 작업은 외부 장치(예: 컴퓨터 하드 디스크, 네트워크 카드 등)와 관련된 작업을 의미합니다. 일반적인 작업에는 파일 읽기 및 쓰기 작업, 네트워크 작업 등이 포함됩니다. 이러한 작업은 처리를 Node.js에 맡기므로 비동기식이어야 합니다.

JavaScript는 컴퓨터의 내부 장치에 액세스할 수 없습니다. 이러한 작업이 수행되면 JavaScript는 백그라운드에서 처리하기 위해 이를 Node.js로 전송합니다.

완료 후에는 이벤트 루프가 실행을 위해 호출 스택으로 전송되도록 IO 콜백 큐로 전송됩니다.

Timer queue

Node.js 타이머 함수(예: setTimeout() 및 setInterval())와 관련된 모든 작업은 타이머 대기열에 추가됩니다. . 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
JavaScript 언어 자체에 유의하세요. 타이머 기능이 없습니다

. Node.js에서 제공하는 타이머 API( setTimeout 포함)를 사용하여 시간 관련 작업을 수행합니다. 따라서 타이머 작업은 비동기식입니다. 2초든 0초든 JavaScript는 시간 관련 작업을 Node.js로 전달한 다음 Node.js가 작업을 완료하고 타이머 대기열에 추가합니다.

예: 🎜

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

🎜비동기 작업을 처리하는 동안 JavaScript는 계속해서 다른 작업을 수행합니다. 모든 동기화 작업이 처리된 후에만 이벤트 루프가 콜백 대기열에 들어갑니다. 🎜

마이크로태스크 큐(Microtask queue) 🎜🎜큐는 두 개의 큐로 나뉩니다: 🎜

• 첫 번째 큐에는 process.nextTick이 포함됩니다. 함수와 지연된 함수. 🎜🎜🎜이벤트 루프에 의해 실행되는 각 반복을 틱(시간 척도)이라고 합니다. 🎜<p><code>process.nextTick 是一个函数，它在下一个 tick （即事件循环的下一个迭代）执行一个函数。微任务队列需要存储此类函数，以便可以在下一个 tick 执行它们。

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

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

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

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

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

  以下代码说明了 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（非阻塞），这意味着异步操作可以被正确的处理。都是因为有了事件循环和回调队列才能使此功能生效。

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

위 내용은 Node.js의 콜백 큐에 대한 심층 분석의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!