前端进阶之JS运行原理和机制详解

前言

之前我们一直说要介绍下前端的知识点，一直没空总结，这不来了;

js运行机制，来一篇总结

一、js的基础知识点介绍

• js作为浏览器脚本语言，它的主要用途是与用户互动，以及操作DOM，因此js是单线程，也避免了同时操作同一个DOM的矛盾问题;
• 为了利用多核CPU的计算能力，H5的Web Worker实现的“多线程”实际上指的是“多子线程”，完全受控于主线程，且不允许操作DOM;
• js引擎存在monitoring process进程，会持续不断的检查主线程执行栈是否为空，一旦为空，就会去Event Queue那里检查是否有等待被调用的函数。这个过程是循环不断的，所以整个的这种运行机制又称为Event Loop(事件循环);
• 所有同步任务都在主线程上执行，形成一个执行栈(execution context stack);
• 如果在微任务执行期间微任务队列加入了新的微任务，会将新的微任务加入队列尾部，之后也会被执行;

二、相关概念

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、任务队列

• "任务队列"是一个事件的队列(也可以理解成消息的队列)，IO设备完成一项任务，就在"任务队列"中添加一个事件，表示相关的异步任务可以进入"执行栈"了。主线程读取"任务队列"，就是读取里面有哪些事件;
• "任务队列"中的事件，除了IO设备的事件以外，还包括一些用户产生的事件(比如鼠标点击、页面滚动等等)。只要指定过回调函数，这些事件发生时就会进入"任务队列"，等待主线程读取。
• 所谓"回调函数"(callback)，就是那些会被主线程挂起来的代码。异步任务必须指定回调函数，当主线程开始执行异步任务，就是执行对应的回调函数;
• "任务队列"是一个先进先出的数据结构，排在前面的事件，优先被主线程读取。主线程的读取过程基本上是自动的，只要执行栈一清空，"任务队列"上第一位的事件就自动进入主线程。但是，由于存在后文提到的"定时器"功能，主线程首先要检查一下执行时间，某些事件只有到了规定的时间，才能返回主线程。
• 读取到一个异步任务，首先是将异步任务放进事件表格(Event table)中，当放进事件表格中的异步任务完成某种事情或者说达成某些条件(如setTimeout事件到了，鼠标点击了，数据文件获取到了)之后，才将这些异步任务推入事件队列(Event Queue)中，这时候的异步任务才是执行栈中空闲的时候才能读取到的异步任务;

5、Event Loop

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

6、setTimeout(fn,0)

• setTimeout(fn,0)的含义是，指定某个任务在主线程最早可得的空闲时间执行，也就是说，尽可能早得执行。它在"任务队列"的尾部添加一个事件，因此要等到同步任务和"任务队列"现有的事件都处理完，才会得到执行。
• HTML5标准规定了setTimeout()的第二个参数的最小值(最短间隔)，不得低于4毫秒，如果低于这个值，就会自动增加。在此之前，老版本的浏览器都将最短间隔设为10毫秒。另外，对于那些DOM的变动(尤其是涉及页面重新渲染的部分)，通常不会立即执行，而是每16毫秒执行一次。这时使用requestAnimationFrame()的效果要好于setTimeout()。
• 需要注意的是，setTimeout()只是将事件插入了"任务队列"，必须等到当前代码(执行栈)执行完，主线程才会去执行它指定的回调函数。要是当前代码耗时很长，有可能要等很久，所以并没有办法保证，回调函数一定会在setTimeout()指定的时间执行

三、js执行机制介绍

1、javascript的同步和异步

• 单线程就意味着，所有任务需要排队，前一个任务结束，才会执行后一个任务。如果前一个任务耗时很长，后一个任务就不得不一直等着。
• 如果排队是因为计算量大，CPU忙不过来，倒也算了，但是很多时候CPU是闲着的，因为IO设备(输入输出设备)很慢(比如Ajax操作从网络读取数据)，不得不等着结果出来，再往下执行。
• JavaScript语言的设计者意识到，这时主线程完全可以不管IO设备，挂起处于等待中的任务，先运行排在后面的任务。等到IO设备返回了结果，再回过头，把挂起的任务继续执行下去。
• 于是，所有任务可以分成两种，一种是同步任务(synchronous)，另一种是异步任务(asynchronous)。同步任务指的是，在主线程上排队执行的任务，只有前一个任务执行完毕，才能执行后一个任务;异步任务指的是，不进入主线程、而进入"任务队列"(task queue)的任务，只有"任务队列"通知主线程，某个异步任务可以执行了，该任务才会进入主线程执行。

• 同步和异步任务分别进入不同的执行"场所"，同步的进入主线程，异步的进入Event Table并注册函数。
• 当Event Table中指定的事情完成时，会将这个函数移入Event Queue。
• 主线程内的任务执行完毕为空，会去Event Queue读取对应的函数，进入主线程执行。
• 上述过程会不断重复，也就是常说的Event Loop(事件循环)。
• 我们不禁要问了，那怎么知道主线程执行栈为空啊?js引擎存在monitoring process进程，会持续不断的检查主线程执行栈是否为空，一旦为空，就会去Event Queue那里检查是否有等待被调用的函数;

2、JavaScript的宏任务与微任务

你是否觉得同步异步的执行机制流程就是JavaScript执行机制的全部?不是的，JavaScript除了广义上的的同步任务何异步任务，其对任务还有更精细的定义：

• macro-task(宏任务)：包括整体代码script，setTimeout，setInterval
• micro-task(微任务)：Promise，process.nextTick

不同类型的任务会进入对应的Event Queue。

事件循环的顺序，决定js代码的执行顺序。进入整体代码(宏任务)后，开始第一次循环。接着执行所有的微任务。然后再次从宏任务开始，找到其中一个任务队列执行完毕，再执行所有的微任务。

3、实例来说明JavaScript的执行机制

3.1、同步

1. console.log(1); 
2. console.log(2); 
3. console.log(3); 
4. /* 
5.     执行结果：1、2、3 
6.     同步任务，按照顺序一步一步执行 
7. */ 

3.2、同步和异步

1. console.log(1); 
2. setTimeout(function() { 
3.     console.log(2); 
4. },1000) 
5. console.log(3); 
6. /* 
7.     执行结果：1、3、2 
8.     同步任务，按照顺序一步一步执行 
9.     异步任务，放入消息队列中，等待同步任务执行结束，读取消息队列执行 
10. */ 

3.3、异步任务进一步分析

1. console.log(1); 
2. setTimeout(function() { 
3.     console.log(2); 
4. },1000) 
5. setTimeout(function() { 
6.     console.log(3); 
7. },0) 
8. console.log(4); 
9. /* 
10.     猜测是：1、4、2、3   但实际上是：1、4、3、2 
11.     分析： 
12.         同步任务，按照顺序一步一步执行 
13.         异步任务，当读取到异步任务的时候，将异步任务放置到Event table（事件表格） 
14. 中，当满足某种条件或者说指定事情完成了（这里的是时间分别是达到了0ms和1000ms）当指定 
15. 事件完成了才从Event table中注册到Event Queue（事件队列），当同步事件完成了，便从 
16. Event Queue中读取事件执行。（因为3的事情先完成了，所以先从Event table中注册到 
17. Event Queue中，所以先执行的是3而不是在前面的2） 
18. */ 

3.4、宏任务和微任务

1. console.log(1); 
2. setTimeout(function() { 
3.     console.log(2) 
4. },1000); 
5. new Promise(function(resolve) { 
6.     console.log(3); 
7.     resolve(); 
8. } 
9. ).then(function() { 
10.     console.log(4) 
11. }); 
12. console.log(5); 
13. /* 
14.     以同步异步的方式来判断的结果应该是：1、3、5、2、4 
15.     但是事实上结果是：1、3、5、4、2 
16.     为什么是这样呢？因为以同步异步的方式来解释执行机制是不准确的，更加准确的方式是宏任务和微任务： 
17.     因此执行机制便为：执行宏任务 ===> 执行微任务 ===> 执行另一个宏任务 ===> 不断循环 
18.         即：在一个事件循环中，执行第一个宏任务，宏任务执行结束，执行当前事件循环中的微任务， 
19. 执行完毕之后进入下一个事件循环中，或者说执行下一个宏任务 
20. */ 

3.5、是否彻底理解JavaScript执行机制实例

1. console.log('1'); 
2. setTimeout(function() { 
3.     console.log('2'); 
4.     process.nextTick(function() { 
5.         console.log('3'); 
6.     }) 
7.     new Promise(function(resolve) { 
8.         console.log('4'); 
9.         resolve(); 
10.     }).then(function() { 
11.         console.log('5') 
12.     }) 
13. }) 
14. process.nextTick(function() { 
15.     console.log('6'); 
16. }) 
17. new Promise(function(resolve) { 
18.     console.log('7'); 
19.     resolve(); 
20. }).then(function() { 
21.     console.log('8') 
22. }) 
23. setTimeout(function() { 
24.     console.log('9'); 
25.     process.nextTick(function() { 
26.         console.log('10'); 
27.     }) 
28.     new Promise(function(resolve) { 
29.         console.log('11'); 
30.         resolve(); 
31.     }).then(function() { 
32.         console.log('12') 
33.     }) 
34. }) 
35. /* 
36. 1、 第一轮事件循环流程分析如下： 
37.     整体script作为第一个宏任务进入主线程，遇到console.log，输出1。 
38.     遇到setTimeout，其回调函数被分发到宏任务Event Queue中。我们暂且记为setTimeout1。 
39.     遇到process.nextTick()，其回调函数被分发到微任务Event Queue中。我们记为process1。 
40.     遇到Promise，new Promise直接执行，输出7。then被分发到微任务Event Queue中。我们记为then1。 
41.     又遇到了setTimeout，其回调函数被分发到宏任务Event Queue中，我们记为setTimeout2。 
42.     宏任务Event Queue   微任务Event Queue 
43.     setTimeout1         process1 
44.     setTimeout2         then1 
45.     上表是第一轮事件循环宏任务结束时各Event Queue的情况，此时已经输出了1和7。 
46.     我们发现了process1和then1两个微任务。 
47.     执行process1,输出6。 
48.     执行then1，输出8。 
49.     好了，第一轮事件循环正式结束，这一轮的结果是输出1，7，6，8。 
50. 2、 那么第二轮时间循环从setTimeout1宏任务开始： 
51.     首先输出2。接下来遇到了process.nextTick()，同样将其分发到微任务Event Queue中， 
52. 记为process2。new Promise立即执行输出4，then也分发到微任务Event Queue中，记为then2。 
53.     宏任务Event Queue     微任务Event Queue 
54.     setTimeout2           process2 
55.                           then2 
56.     第二轮事件循环宏任务结束，我们发现有process2和then2两个微任务可以执行。 
57.         输出3。 
58.         输出5。 
59.         第二轮事件循环结束，第二轮输出2，4，3，5。 
60. 3、 第三轮事件循环开始，此时只剩setTimeout2了，执行。 
61.         直接输出9。 
62.         将process.nextTick()分发到微任务Event Queue中。记为process3。 
63.         直接执行new Promise，输出11。 
64.         将then分发到微任务Event Queue中，记为then3。 
65.     宏任务Event Queue     微任务Event Queue 
66.                             process3 
67.                             then3      
68.     第三轮事件循环宏任务执行结束，执行两个微任务process3和then3。 
69.         输出10。 
70.         输出12。 
71.         第三轮事件循环结束，第三轮输出9，11，10，12。 
72.     整段代码，共进行了三次事件循环，完整的输出为1，7，6，8，2，4，3，5，9，11，10，12。 
73. */ 

总结

javascript是一门单线程语言;

Event Loop是javascript的执行机制;

客户端也是要学习前端语言的，以后我们会讲解一些前端的知识点

本文转载自微信公众号「Android开发编程」

原文链接：https://mp.weixin.qq.com/s/0O8X8ai2pRgKUCuzFKlhsg