实例分析JS与Node.js中的事件循环

这两天跟同事同事讨论遇到的一个问题，js中的event loop，引出了chrome与node中运行具有settimeout和promise的程序时候执行结果不一样的问题，从而引出了nodejs的event loop机制，记录一下，感觉还是蛮有收获的

console.log(1)
settimeout(function() {
 new promise(function(resolve, reject) {
 console.log(2)
 resolve()
 })
 .then(() => {
 console.log(3)
 })
}, 0)
settimeout(function() {
 console.log(4)
}, 0)
// chrome中运行：1 2 3 4
// node中运行： 1 2 4 3

chrome和node执行的结果不一样，这就很有意思了。

1. js 中的任务队列

javascript语言的一大特点就是单线程，也就是说，同一个时间只能做一件事。那么，为什么javascript不能有多个线程呢？这样能提高效率啊。

javascript的单线程，与它的用途有关。作为浏览器脚本语言，javascript的主要用途是与用户互动，以及操作dom。这决定了它只能是单线程，否则会带来很复杂的同步问题。比如，假定javascript同时有两个线程，一个线程在某个dom节点上添加内容，另一个线程删除了这个节点，这时浏览器应该以哪个线程为准？

所以，为了避免复杂性，从一诞生，javascript就是单线程，这已经成了这门语言的核心特征，将来也不会改变。

为了利用多核cpu的计算能力，html5提出web worker标准，允许javascript脚本创建多个线程，但是子线程完全受主线程控制，且不得操作dom。所以，这个新标准并没有改变javascript单线程的本质。

2. 任务队列 event loop

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

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

具体来说，异步执行的运行机制如下。（同步执行也是如此，因为它可以被视为没有异步任务的异步执行。）

所有同步任务都在主线程上执行，形成一个执行栈（execution context stack）。主线程之外，还存在一个"任务队列"（task queue）。只要异步任务有了运行结果，就在"任务队列"之中放置一个事件。一旦"执行栈"中的所有同步任务执行完毕，系统就会读取"任务队列"，看看里面有哪些事件。那些对应的异步任务，于是结束等待状态，进入执行栈，开始执行。主线程不断重复上面的第三步。

只要主线程空了，就会去读取"任务队列"，这就是javascript的运行机制。这个过程会不断重复。

3. 定时器 settimeout与setinterval

定时器功能主要由settimeout()和setinterval()这两个函数来完成，它们的内部运行机制完全一样，区别在于前者指定的代码是一次性执行，后者则为反复执行。

settimeout(fn,0)的含义是，指定某个任务在主线程最早可得的空闲时间执行，也就是说，尽可能早得执行。它在"任务队列"的尾部添加一个事件，因此要等到同步任务和"任务队列"现有的事件都处理完，才会得到执行。

html5标准规定了settimeout()的第二个参数的最小值（最短间隔），不得低于4毫秒，如果低于这个值，就会自动增加。在此之前，老版本的浏览器都将最短间隔设为10毫秒。另外，对于那些dom的变动（尤其是涉及页面重新渲染的部分），通常不会立即执行，而是每16毫秒执行一次。这时使用requestanimationframe()的效果要好于settimeout()。

需要注意的是，settimeout()只是将事件插入了"任务队列"，必须等到当前代码（执行栈）执行完，主线程才会去执行它指定的回调函数。要是当前代码耗时很长，有可能要等很久，所以并没有办法保证，回调函数一定会在settimeout()指定的时间执行。

4. node.js的event loop

事件轮询主要是针对事件队列进行轮询，事件生产者将事件排队放入队列中，队列另外一端有一个线程称为事件消费者会不断查询队列中是否有事件，如果有事件，就立即会执行，为了防止执行过程中有堵塞操作影响当前线程读取队列，事件消费者线程会委托一个线程池专门执行这些堵塞操作。

javascript前端和node.js的机制类似这个事件轮询模型，有的人认为node.js是单线程，也就是事件消费者是单线程不断轮询，如果有堵塞操作怎么办，不是堵塞了当前单线程的执行吗？

其实node.js底层也有一个线程池，线程池专门用来执行各种堵塞操作，这样不会影响单线程这个主线程进行队列中事件轮询和一些任务执行，线程池操作完以后，又会作为事件生产者将操作结果放入同一个队列中。

总之，一个事件轮询event loop需要三个组件：

事件队列event queue，属于fifo模型，一端推入事件数据，另外一端拉出事件数据，两端只通过这个队列通讯，属于一种异步的松耦合。队列的读取轮询线程，事件的消费者，event loop的主角。单独线程池thread pool，专门用来执行长任务，重任务，干繁重体力活的。

node.js也是单线程的event loop，但是它的运行机制不同于浏览器环境。

根据上图，node.js的运行机制如下。

v8引擎解析javascript脚本。解析后的代码，调用node api。 libuv库负责node api的执行。它将不同的任务分配给不同的线程，形成一个event loop（事件循环），以异步的方式将任务的执行结果返回给v8引擎。 v8引擎再将结果返回给用户。

我们可以看到node.js的核心实际上是libuv这个库。这个库是c写的，它可以使用多线程技术，而我们的javascript应用是单线程的。

nodejs 的异步任务执行流程：

用户写的代码是单线程的，但nodejs内部并不是单线程！

事件机制：

node.js不是用多个线程为每个请求执行工作的，相反而是它把所有工作添加到一个事件队列中，然后有一个单独线程，来循环提取队列中的事件。事件循环线程抓取事件队列中最上面的条目，执行它，然后抓取下一个条目。当执行长期运行或有阻塞i/o的代码时

在node.js中，因为只有一个单线程不断地轮询队列中是否有事件，对于数据库文件系统等i/o操作，包括http请求等等这些容易堵塞等待的操作，如果也是在这个单线程中实现，肯定会堵塞影响其他工作任务的执行，javascript/node.js会委托给底层的线程池执行，并会告诉线程池一个回调函数，这样单线程继续执行其他事情，当这些堵塞操作完成后，其结果与提供的回调函数一起再放入队列中，当单线程从队列中不断读取事件，读取到这些堵塞的操作结果后，会将这些操作结果作为回调函数的输入参数，然后激活运行回调函数。

请注意，node.js的这个单线程不只是负责读取队列事件，还会执行运行回调函数，这是它区别于多线程模式的一个主要特点，多线程模式下，单线程只负责读取队列事件，不再做其他事情，会委托其他线程做其他事情，特别是多核的情况下，一个cpu核负责读取队列事件，一个cpu核负责执行激活的任务，这种方式最适合很耗费cpu计算的任务。反过来，node..js的执行激活任务也就是回调函数中的任务还是在负责轮询的单线程中执行，这就注定了它不能执行cpu繁重的任务，比如json转换为其他数据格式等等，这些任务会影响事件轮询的效率。

5. nodejs特点

nodejs的显著特点：异步机制、事件驱动。

事件轮询的整个过程没有阻塞新用户的连接，也不需要维护连接。基于这样的机制，理论上陆续有用户请求连接，nodejs都可以进行响应，因此nodejs能支持比java、php程序更高的并发量。

虽然维护事件队列也需要成本，再由于nodejs是单线程，事件队列越长，得到响应的时间就越长，并发量上去还是会力不从心。

restful api是nodejs最理想的应用场景，可以处理数万条连接，本身没有太多的逻辑，只需要请求api，组织数据进行返回即可。

6. 实例

看一个具体实例：

console.log('1')
settimeout(function() {
 console.log('2')
 new promise(function(resolve) {
 console.log('4')
 resolve()
 }).then(function() {
 console.log('5')
 })
 settimeout(() => {
 console.log('haha')
 })
 new promise(function(resolve) {
 console.log('6')
 resolve()
 }).then(function() {
 console.log('66')
 })
})
settimeout(function() {
 console.log('hehe')
}, 0)
new promise(function(resolve) {
 console.log('7')
 resolve()
}).then(function() {
 console.log('8')
})
settimeout(function() {
 console.log('9')
 new promise(function(resolve) {
 console.log('11')
 resolve()
 }).then(function() {
 console.log('12')
 })
})
new promise(function(resolve) {
 console.log('13')
 resolve()
}).then(function() {
 console.log('14')
})
// node1 : 1,7,13,8,14,2,4,6,hehe,9,11,5,66,12,haha // 结果不稳定
// node2 : 1,7,13,8,14,2,4,6,hehe,5,66,9,11,12,haha // 结果不稳定
// node3 : 1,7,13,8,14,2,4,6,5,66,hehe,9,11,12,haha // 结果不稳定
// chrome : 1,7,13,8,14,2,4,6,5,66,hehe,9,11,12,haha

chrome的运行比较稳定，而node环境下运行不稳定，可能会出现两种情况。

chrome运行的结果的原因是promise、process.nexttick()的微任务event queue运行的权限比普通宏任务event queue权限高，如果取事件队列中的事件的时候有微任务，就先执行微任务队列里的任务，除非该任务在下一轮的event loop中，微任务队列清空了之后再执行宏任务队列里的任务。