标签: event-loop

Node.js文档说：

定时器的执行顺序将根据调用它们的上下文而有所不同。如果两者都从主模块中调用，则计时将受进程性能的限制（这可能会受到机器上运行的其他应用程序的影响）。

例如，如果我们运行以下不在 I/O 周期（即主模块）内的脚本，则两个计时器的执行顺序是不确定的，因为它受进程性能的约束：

// timeout_vs_immediate.js
setTimeout(function timeout () {
 console.log('timeout');
},0);

setImmediate(function immediate () {
  console.log('immediate');
});

$ node timeout_vs_immediate.js
timeout
immediate

$ node timeout_vs_immediate.js
immediate
timeout

Run Code Online (Sandbox Code Playgroud)

在同一页面上，我想我了解事件循环的工作原理，但是在这次主要运行之后，为什么偶数循环不能正确完成其工作？那里与 I/O 周期内有什么不同？

我阅读了大量文章和stackoverflow问题，也看到了很多关于线程池的信息，但没有人谈论物理CPU内核使用情况。我相信这个问题没有重复。

鉴于我有一台四核计算机和大小为 4 的 libuv 线程池，Node.js 在处理大量 i/o 请求（可能超过数千个）时是否会利用所有这 4 个内核？

我也很好奇哪个i/o 请求使用thread pool。没有人给出清晰完整的请求清单。我知道 Node.js 事件循环是单线程的，但使用线程池来处理 I/O，例如访问磁盘和数据库。

我正在学习 Node Js，我理解 node js 的核心是基于事件循环的反应器模式。

当任何事件发生时，它会进入事件队列，然后在运行任务结束后被堆栈拾取，如果事件是非阻塞事件，则会发生这种情况，但如果它是阻塞请求，则事件循环将其传递给来自 libuv 线程池的线程。

现在我的疑问是：

1. 一旦执行结束，libuv 线程是否将请求传递回事件队列或事件循环？，不同的教程有不同的场景。

2. libuv 中的线程池还有 3 个线程，现在假设 10 个用户尝试同时登录每个人（某些应用程序，例如 facebook 等），仅如何，并且线程在他们想连接到数据库时被阻塞，那么如何仅三个线程会处理这么多负载吗？

我真的很困惑，在任何地方都没有得到对这些疑问的很好解释，任何帮助将不胜感激。

我有一段简单的代码让我发疯了一段时间。几天前我发布了这个问题，询问create_task是否与input. 现在我想出了一些与此相关的事情。我在一个单独的线程中运行事件循环并在其中推送任务。非常直接的代码。

import asyncio
import threading


async def printer(message):
    print(f'[printer] {message}')


def loop_runner(loop):
    loop.run_forever()


if __name__ == '__main__':
    event_loop = asyncio.get_event_loop()
    t = threading.Thread(target=loop_runner, args=(event_loop,))
    t.start()

    for m in ['hello', 'world', 'foo', 'bar']:
        print(f'[loop running ?] {event_loop.is_running()}')
        event_loop.create_task(printer(m))

除了这些日志消息外，什么都不会打印。

[loop running ?] True
[loop running ?] True
[loop running ?] True
[loop running ?] True

现在，如果我在事件循环线程中阻塞并让它在像这样暂停后运行。

def loop_runner(loop):
    time.sleep(1 / 1000)
    loop.run_forever()

一切正常，这被打印出来

[loop running ?] False
[loop running ?] False
[loop running ?] …

在这段视频(10:00) 中，这家伙说无限while (true);循环会阻止渲染，这会使 gif 停止动画。但是当我自己尝试代码时，我仍然无法选择段落文本，但是gif仍然是动画，我哪里误解了？我的代码和视频中的代码有什么区别？我的代码在这里：

<img src="https://media.giphy.com/media/3o85xsGXVuYh8lM3EQ/giphy.gif" alt="">
<button id="click">Click Me</button>
<p>Lorem ipsum dolor sit amet consectetur adipisicing elit. Quam saepe ratione possimus reiciendis ad ipsa architecto mollitia deserunt, delectus optio soluta quisquam magni ducimus sapiente vero. Cupiditate, et reprehenderit! Ea placeat sit a ab</p>

<script>
  document.getElementById("click").addEventListener("click", ev => {
    while (true) {
      console.log("in the loop")
    }
  })
</script>

这个问题的直接答案是：行为实际上不同于 Chrome 和 Firefox（其他浏览器也是如此）。当我尝试使用 Firefox 时，gif 被阻止（如视频中所示），但在 Chrome 中，它仍在动画中。

如果我使用（或 with ，其行为方式相同）安排回调loop.call_later()loop.call_at()，是否可以取消其执行？

为什么？假设我安排某件事从现在起一分钟后运行。但是，由于某些情况，代码决定中止该执行（因为不再需要它），或者决定重新安排另一个时间。问题是如何使用Python来实现它asyncio？

如果您熟悉 JavaScript，我正在寻找setTimeout()和的等效项clearTimeout()。

我已阅读官方文档和许多其他博客，process.nextTick()但我对某些主题有点困惑。

首先，写入中的回调process.nextTick()在下一次迭代开始之前执行。

其次，当在 I/O 周期内时，事件循环当前处于轮询阶段。在轮询阶段之后，事件循环进入检查阶段，在该阶段执行setImmediate方法中调用的任何回调。

现在在下面的代码中

const fs = require('fs');

function main() {
   fs.readFile('./xy.txt', function(err, buff){
      setTimeout(()=> console.log("timeout inside fs"),0);
      setImmediate(()=> console.log("immediate inside fs"));
      process.nextTick(()=>{console.log("process.nextTick")});
      console.log("inside fs");
   })
   console.log("called inside main fn in first-iteration");
}

main();
console.log("called in first-iteration);

输出将是：

const fs = require('fs');

function main() {
   fs.readFile('./xy.txt', function(err, buff){
      setTimeout(()=> console.log("timeout inside fs"),0);
      setImmediate(()=> console.log("immediate inside fs"));
      process.nextTick(()=>{console.log("process.nextTick")});
      console.log("inside fs");
   })
   console.log("called inside main fn in first-iteration");
}

main();
console.log("called in first-iteration);

在此期间， …

我试图理解异步 JavaScript，但我想知道的一件事是，事件循环是否在主线程上运行？如果是这样，是否所有同步代码都Main()必须经过事件循环？（例如，console.log("Hello")还必须经过事件循环吗？）
并且事件循环是唯一允许将函数推送到调用堆栈的循环吗？

根据这个答案：

“重要的是要考虑到 Promise 中的 then/catch 回调是微任务，并将在 nextTick 任务之后执行”

Nodejs 文档提到 nextTickQueue 将在当前操作完成后处理，无论事件循环的当前阶段如何。这是否意味着已解决的承诺回调既不会在轮询阶段执行，也不会在挂起的回调阶段执行？

此外，该视频提到有一个queueMicroTask 队列，该队列在事件循环的当前阶段之后进行处理。所以我现在明白的是：

已解决的 Promise 回调将添加到queueMicroTask中，该回调将在nextTickQueue（回调传递给process.nextTick）之后进行处理，无论事件循环的当前阶段是什么，都会在nextTickQueue之后进行处理。

那是对的吗？如果不对请纠正我，我真的很困惑。

我已经使用 Node.JS 一段时间了，只是想知道当多个客户端导致一些阻塞/耗时的工作响应时它如何处理？

考虑以下情况 1- 有许多端点，其中一个端点很耗时并且在几秒钟内做出响应。2- 假设有 100 个客户端同时向我的端点发出请求，其中一个客户端需要相当长的时间。

该端点是否会阻止所有事件循环并使其他请求等待？

或者，一般来说，Node.JS 中的请求会互相阻塞吗？

如果没有，为什么？既然是单线程，为什么不互相阻塞呢？