javascript - 我对异步操作的理解正确吗？

Closed. This question needs to be more focused。它当前不接受答案。

想改善这个问题吗？更新问题，使其仅关注editing this post的一个问题。

5个月前关闭。

Improve this question

我正在努力掌握异步性的概念。关于异步操作，以下内容大致正确吗？

如果一段代码需要很长时间才能完成，则可能会出现问题。这是因为i)它停止了下面的代码的运行，并且在将硬代码加载到后台的同时运行它可能会更好。 ii)实际上，JS可能会在硬代码完成之前尝试执行以下代码。如果下面的代码依赖于硬代码，那就是一个问题。

一种解决方案是:如果某个操作需要很长时间才能完成，则您希望在处理原始线程时在单独的线程中进行处理。只要确保主线程没有引用异步操作返回的内容即可。 JS为该解决方案采用了事件队列。异步操作在事件线程中执行，该事件在主线程之后执行。

但是，即使事件队列也可能遭受与主线程相同的问题。如果位于fetch2上方的fetch1需要很长时间才能返回 promise ，而fetch2却没有，则JS可能会在执行fetch1之前开始执行fetch2。这是Promise.all有用的地方，因为在fetch1和fetch2的 promise 都得到解决之前，它不会继续进行异步操作的下一步。

另外，我在链接.then时已读过它，这被视为一次异步操作，因此我们始终可以保证后续的.then仅在.then履行 promise 之前执行。

最佳答案

几乎正确，但不太正确。
如果您正在谈论英语中的“异步性”一词，那么这意味着事情可能会发生困惑。许多语言都使用了此概念，包括Java和C / C++中的多线程。
如果您正在谈论异步性的特定概念，因为它与C / C++中的node.js或异步I / O有关，那么您对它在底层如何工作确实有一些误解。

A problem can occur if a piece of code takes a long time to complete. This is because i) it stops code below from running and it might be nice to run this whilst the hard code loads in the background. And ii) Indeed, JS might try to execute the code below before the hard code’s finished. If the code below relies on the hard code, that’s a problem.

当谈论C / C++中的javascript或异步I / O(javascript从那里获得异步性)时，这是不正确的。
实际发生的事情是等待某件事发生可能需要很长时间才能完成。与其等着，为什么不告诉操作系统一旦事情发生就执行一些代码(您的回调)。
在OS级别，大多数现代操作系统都有API，可让您告诉它在发生某些情况时唤醒您的进程。那件事可能是键盘事件，鼠标事件，I / O事件(来自磁盘或网络)，系统重新配置事件(例如，更改显示器分辨率)等。
大多数传统语言都实现阻塞I / O。发生的情况是，当您尝试从磁盘或网络读取内容时，进程会立即进入睡眠状态，并且操作系统将在数据到达时再次将其唤醒:
Traditional blocking I/O

 time
  │
  ├────── your code doing stuff ..
  ├────── read_data_from_disk() ───────────────────┐
  ┆                                                ▼
  :                                        OS puts process to sleep
  .
  .                                         other programs running ..
  .
  :                                            data arrives ..
  ┆                                        OS wakes up your process   
  ├────── read_data_from_disk() ◀──────────────────┘
  ├────── your program resume doing stuff ..
  ▼
这意味着您的程序一次只能等待一件事。这意味着您的程序大多数时候都没有使用CPU。侦听更多事件的传统解决方案是多线程。每个线程将分别阻塞其事件，但是您的程序可以为其感兴趣的每个事件生成一个新线程。
事实证明，每个线程等待一个事件的幼稚多线程处理速度很慢。而且最终会消耗大量RAM，尤其是对于脚本语言。所以这不是javascript所做的。

Note: Historically the fact that javascript uses a single thread instead of multithreading is a bit of an accident. It was just the result of decisions made by the team that added progressive JPEG rendering and GIF animations to early browsers. But by happy coincidence this is exactly what makes things like node.js fast.

JavaScript要做的是等待多个事件，而不是等待单个事件。所有现代操作系统都有API，可让您等待多个事件。它们的范围从BSD和Mac OSX上的queue / kqueue到Linux上的poll/epoll到Windows上的重叠I / O到跨平台POSIX select() 系统调用。
javascript处理外部事件的方式如下所示:
Non-blocking I/O (also known as asynchronous I/O)

 time
  │
  ├────── your code doing stuff ..
  ├────── read_data_from_disk(read_callback) ───▶ javascript stores
  │                                               your callback and
  ├────── your code doing other stuff ..          remember your request
  │
  ├────── wait_for_mouse_click(click_callback) ─▶ javascript stores
  │                                               your callback and
  ├────── your code doing other stuff ..          remember your request
  │
  ├────── your finish doing stuff.
  ┆       end of script ─────────────▶ javascript now is free to process
  ┆                                  pending requests (this is called
  ┆                                  "entering the event loop").
  ┆                                  Javascript tells the OS about all the
  :                                  events it is interested in and waits..
  .                                            │
  .                                            └───┐
  .                                                ▼
  .                                        OS puts process to sleep
  .
  .                                         other programs running ..
  .
  .                                            data arrives ..
  .                                        OS wakes up your process
  .                                                │
  .                                            ┌───┘
  :                                            ▼
  ┆                       Javascript checks which callback it needs to call
  ┆                          to handle the event. It calls your callback.
  ├────── read_callback() ◀────────────────────┘
  ├────── your program resume executing read_callback
  ▼
主要区别在于同步多线程代码在每个线程中等待一个事件。异步代码(例如javascript之类的单线程或Nginx或Apache之类的多线程)会在每个线程中等待多个事件。

Note: Node.js handles disk I/O in separate threads but all network I/O are processed in the main thread. This is mainly because asynchronous disk I/O APIs are incompatible across Windows and Linux/Unix. However it is possible to do disk I/O in the main thread. The Tcl language is one example that does asynchronous disk I/O in the main thread.
A solution is: if an operation takes a long time to complete, you want to process it in a separate thread while the original thread is processed.

除了Web worker(或Node.js中的worker线程)之外，javascript中的异步操作不会发生这种情况。对于Web Worker，则是，您正在其他线程中执行代码。
But even the event-que can suffer from the same problem as the main-thread. If fetch1, which is positioned above fetch2, takes a long time to return a promise, and fetch2 doesn’t, JS might start executing fetch2 before executing fetch1

这不是正在发生的事情。您正在执行以下操作:
fetch(url_1).then(fetch1); // tell js to call fetch1 when this completes
fetch(url_2).then(fetch2); // tell js to call fetch2 when this completes
并不是js“可能”开始执行。上面的代码发生的事情是两个获取都是同步执行的。也就是说，第一次获取严格发生在第二次获取之前。
但是，以上所有代码所做的是告诉javascript在以后的某个时间回调函数fetch1和fetch2。 这是记住的重要类(class)。 上方的代码不执行，fetch1和fetch2函数(回调)。您要做的就是告诉javascript在数据到达时调用它们。
如果您执行以下操作:
fetch(url_1).then(fetch1); // tell js to call fetch1 when this completes
fetch(url_2).then(fetch2); // tell js to call fetch2 when this completes

while (1) {
    console.log('wait');
}
然后，fetch1和fetch2 将永远不会执行。
我在这里暂停，让您考虑一下。
记住异步I / O是如何处理的。实际上，所有I / O(通常称为异步)函数调用均不会导致I / O立即被访问。他们所做的只是提醒javascript您想要某些东西(单击鼠标，网络请求，超时等)，并且您希望javascript在该东西完成后执行您的功能。 仅当没有更多代码可以执行时，才在脚本末尾处理异步I / O。
这确实意味着您不能在JavaScript程序中使用无限while循环。不是因为javascript不支持它，而是有一个内置的while循环围绕着您的整个程序:这个大的while循环称为事件循环。

On a separate note, I’ve read when chaining .then, that counts as one asynchronous operation.

是的，这是设计使然，以避免在处理 promise 时使人们感到困惑。
如果您对操作系统如何处理所有这些而不需要进一步创建线程感兴趣，那么您可能会对我对以下相关问题的回答感兴趣:
Is there any other way to implement a "listening" function without an infinite while loop?
node js - what happens to incoming events during callback excution
TLDR
如果没有别的，我希望您了解两件事:
Javascript是严格的同步编程语言。代码中的每个语句都严格按顺序执行。

所有语言的异步代码(是的，包括C / C++以及Java和Python等)将在以后的任何时间调用您的回调。您的回调不会立即被调用。异步性是一个函数调用级别的概念。

异步性*并不是说javascript有什么特别之处。只是大多数javascript库在默认情况下是异步的(尽管您也可以用任何其他语言编写异步代码，但是它们的库通常在默认情况下是同步的)。

*Note: of course, things like async/await does make javascript more capable of handling asynchronous code.

Side note: Promises are nothing special. It is just a design pattern. It is not something built-in to javascript syntax. It is just that newer versions of javascript comes with Promises as part of its standard library. You could have always used promises even with very old versions of javascript and in other languages (Java8 and above for example call have promises in their standard library but call them Futures).

关于javascript - 我对异步操作的理解正确吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/62970655/

上一篇：javascript - 从 html 代码中删除函数和属性

下一篇：javascript - 为什么这个 'repeated character"查找功能不能正常工作？

Javascript 字符串替换不起作用

javascript - 在 NodeJS 中显示 HTML

javascript - 如何使用 jQuery 动态创建棋盘

javascript - 无论顺序如何，Chai 断言 2 个数组是否相等

Javascript:编写返回 promise 的函数

javascript - 页面跳转后下拉菜单停止工作

javascript - js模式问题

javascript - 如何在javascript中的私有(private)方法中使用公共(public)属性？

javascript - 上一页、下一页 javascript