通俗易懂——js运行机制

js 单线程运行之下分同步和异步，先执行所有同步任务再执行异步任务，异步任务进入任务队列，分为宏任务和微任务，主线程为空时先执行微任务，然后逐个执行宏任务. ------个人通俗理解

一. 概念问题

1. JS 为什么是单线程的？

JavaScript 语言的一大特点就是单线程，也就是说，同一个时间只能做一件事。那么，为什么 JavaScript 不能有多个线程呢？这样能提高效率啊。
JavaScript 的单线程，与它的用途有关。作为浏览器脚本语言，JavaScript 的主要用途是与用户互动，以及操作 DOM。这决定了它只能是单线程，否则会带来很复杂的同步问题。比如，假定 JavaScript 同时有两个线程，一个线程在某个 DOM 节点上添加内容，另一个线程删除了这个节点，这时浏览器应该以哪个线程为准？
所以，为了避免复杂性，从一诞生，JavaScript 就是单线程，这已经成了这门语言的核心特征，将来也不会改变。
为了利用多核 CPU 的计算能力，HTML5 提出 Web Worker 标准，允许 JavaScript 脚本创建多个线程，但是子线程完全受主线程控制，且不得操作 DOM。所以，这个新标准并没有改变 JavaScript 单线程的本质。

2. JS 为什么需要异步?

如果 JS 中不存在异步，只能自上而下执行，如果上一行解析时间很长，那么下面的代码就会被阻塞。 对于用户而言，阻塞就意味着"卡死"，这样就导致了很差的用户体验。

3. JS 单线程又是如何实现异步的呢？

既然 JS 是单线程的，只能在一条线程上执行，又是如何实现的异步呢？

是通过的事件循环(event loop)，理解了 event loop 机制，就理解了 JS 的执行机制。

4. JS 中的异步操作有哪些?

• setTimeOut
• setInterval
• ajax
• promise
• I/O

注意: new Promise 是会进入到主线程中立刻执行，而 promise.then 则属于微任务

5. 同步任务 VS 异步任务

• 同步任务(synchronous)：在主线程上排队执行的任务，只有前一个任务执行完毕，才能执行后一个任务；
• 异步任务(asynchronous)：不进入主线程、而进入"任务队列"（task queue）的任务，只有"任务队列"通知主线程，某个异步任务可以执行了，该任务才会进入主线程执行。

二. 任务队列 (task queue)

背景

单线程就意味着，所有任务需要排队，前一个任务结束，才会执行后一个任务。如果前一个任务耗时很长，后一个任务就不得不一直等着。

如果排队是因为计算量大，CPU 忙不过来，倒也算了，但是很多时候 CPU 是闲着的，因为 IO 设备（输入输出设备）很慢（比如 Ajax 操作从网络读取数据），不得不等着结果出来，再往下执行。

JavaScript 语言的设计者意识到，这时主线程完全可以不管 IO 设备，挂起处于等待中的任务，先运行排在后面的任务。等到 IO 设备返回了结果，再回过头，把挂起的任务继续执行下去。

于是，所有任务可以分成两种，一种是同步任务（synchronous），另一种是异步任务（asynchronous）。同步任务指的是，在主线程上排队执行的任务，只有前一个任务执行完毕，才能执行后一个任务；异步任务指的是，不进入主线程、而进入"任务队列"（task queue）的任务，只有"任务队列"通知主线程，某个异步任务可以执行了，该任务才会进入主线程执行。

过程

（1）所有同步任务都在主线程上执行，形成一个执行栈（execution context stack）。

（2）主线程之外，还存在一个"任务队列"（task queue）。只要异步任务有了运行结果，就在"任务队列"之中放置一个事件。

（3）一旦"执行栈"中的所有同步任务执行完毕，系统就会读取"任务队列"，看看里面有哪些事件。那些对应的异步任务，于是结束等待状态，进入执行栈，开始执行。

（4）主线程不断重复上面的第三步。

主线程从"任务队列"中读取事件，这个过程是循环不断的，所以整个的这种运行机制又称为 Event Loop（事件循环）。

image

关于事件和回调函数

"任务队列"是一个事件的队列（也可以理解成消息的队列），IO 设备完成一项任务，就在"任务队列"中添加一个事件，表示相关的异步任务可以进入"执行栈"了。主线程读取"任务队列"，就是读取里面有哪些事件。

"任务队列"中的事件，除了 IO 设备的事件以外，还包括一些用户产生的事件（比如鼠标点击、页面滚动等等）。只要指定过回调函数，这些事件发生时就会进入"任务队列"，等待主线程读取。

所谓"回调函数"（callback），就是那些会被主线程挂起来的代码。异步任务必须指定回调函数，当主线程开始执行异步任务，就是执行对应的回调函数。

"任务队列"是一个先进先出的数据结构，排在前面的事件，优先被主线程读取。主线程的读取过程基本上是自动的，只要执行栈一清空，"任务队列"上第一位的事件就自动进入主线程。但是，由于存在后文提到的"定时器"功能，主线程首先要检查一下执行时间，某些事件只有到了规定的时间，才能返回主线程。

三. 宏任务 和 微任务

注意: new Promise 是会进入到主线程中立刻执行，而 promise.then 则属于微任务

以下宏任务,微任务按优先级排序

四. Event Loop （事件循环）

Event Loop(事件循环)是 JavaScript 的执行机制。

image

• 整体的 script(作为第一个宏任务)开始执行的时候，会把所有代码分为两部分：“同步任务”、“异步任务”；
• 同步任务会直接进入主线程依次执行；
• 异步任务会再分为宏任务和微任务；
• 宏任务进入到 Event Table 中，并在里面注册回调函数，每当指定的事件完成时，Event Table 会将这个函数移到 Event Queue 中；
• 微任务也会进入到另一个 Event Table 中，并在里面注册回调函数，每当指定的事件完成时，Event Table 会将这个函数移到 Event Queue 中；
• 当主线程内的任务执行完毕，主线程为空时，会检查微任务的 Event Queue，如果有任务，就全部执行，如果没有就执行下一个宏任务；
• 上述过程会不断重复，这就是 Event Loop 事件循环；

五. 练习

练习 1

console.log(1);

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

Promise.resolve()
  .then(function () {
    console.log(3);
  })
  .then(function () {
    console.log("4.我是新增的微任务");
  });

console.log(5);

// 执行结果：
// 1，5，3，4.我是新增的微任务，2

练习 2

function add(x, y) {
  console.log(1);
  setTimeout(function () {
    // timer1
    console.log(2);
  }, 1000);
}
add();

setTimeout(function () {
  // timer2
  console.log(3);
});

new Promise(function (resolve) {
  console.log(4);
  setTimeout(function () {
    // timer3
    console.log(5);
  }, 100);
  for (var i = 0; i < 100; i++) {
    i == 99 && resolve();
  }
}).then(function () {
  setTimeout(function () {
    // timer4
    console.log(6);
  }, 0);
  console.log(7);
});

console.log(8);

执行结果;
//1，4，8，7，3，6，5，2

练习 3

console.log("1");

setTimeout(function () {
  console.log("2");
  process.nextTick(function () {
    console.log("3");
  });
  new Promise(function (resolve) {
    console.log("4");
    resolve();
  }).then(function () {
    console.log("5");
  });
});

process.nextTick(function () {
  console.log("6");
});

new Promise(function (resolve) {
  console.log("7");
  resolve();
}).then(function () {
  console.log("8");
});

setTimeout(function () {
  console.log("9");
  process.nextTick(function () {
    console.log("10");
  });
  new Promise(function (resolve) {
    console.log("11");
    resolve();
  }).then(function () {
    console.log("12");
  });
});

// 结果
// 1,7,6,8,2,4,3,5,9,11,10,12

解释:

• 1、第一轮循环开始：

整体 script 作为第一个宏任务进入主线程，遇到 console.log，输出 1。

遇到 setTimeout，其中调回调函数被分为宏任务 Event Queue 中，我们暂记为 setTimeout1。

遇到 process.nextTick()，其回调函数被分到微任务 Event Queue 中。我们记为 process1。

遇到 Promise，new Promise 直接执行，输出 7，then 被分到微任务 Event Queue 中，我们记为 then1。

又遇到了 setTimeout，其回调函数被分到到宏任务 Event Queue 中，我们记为 setTimeout2。

上表示第一轮时间循环宏任务结束时各 Event Queue 的情况，此时已经输出 1 和 7。

我们发现了 process1 和 then1 两个微任务。

执行 process1，输出 6。

执行 then1，输出 8。

• 2、第一轮循环结束，输出 1，7，6，8。第二轮循环从 setTimeout1 宏任务开始：

首先输出 2，接下来遇到了process.nextTick()，同样将其分到微任务 Event Queue 中，记为process2。new Promise立即执行输出 4，then也分到微任务 Event Queue 中，记为then2。

第二轮时间循环宏任务结束，我们发现有process2和then2两个微任务可以执行。

输出 3。

输出 5。

第二轮事件循环结束，第二轮输出 2，4，3，5。

• 3、第三轮循环开始，只剩 setTimeout2 待执行

直接输出 9。

将process.nextTick()分发到微任务 Event Queue 中，记为process3。

直接执行，输出 11。

将then分发到微任务 Event Queue 中，记为then3。

第三轮循环结束，执行了两个微任务process3和then3。

输出 10。

输出 12。

第三轮事件循环结束，第三轮输出 9，11，10，12。

参考文章:
https://www.ruanyifeng.com/blog/2014/10/event-loop.html > https://blog.csdn.net/only_alive/article/details/113768116