本文的目的就是要保证你彻底弄懂javascript的执行机制。
不论你是javascript新手还是老鸟,不论是面试求职,还是日常开发工作,我们经常会遇到这样的情况:给定的几行代码,我们需要知道其输出内容和顺序。因为javascript是一门单线程语言,所以我们可以得出结论:
- javascript是按照语句出现的顺序执行的
看到这里读者要打人了:我难道不知道js是一行一行执行的?还用你说?稍安勿躁,正因为js是一行一行执行的,所以我们以为js都是这样的:
-
let a = '1';
-
console.log(a);
-
let b = '2';
-
console.log(b);复制代码
然而实际上js是这样的:
-
setTimeout(function(){
-
console.log('定时器开始啦')
-
});
-
new Promise(function(resolve){
-
console.log('马上执行for循环啦');
-
for(var i = 0; i < 10000; i++){
-
i == 99 && resolve();
-
}
-
}).then(function(){
-
console.log('执行then函数啦')
-
});
-
console.log('代码执行结束');复制代码
依照js是按照语句出现的顺序执行这个理念,我自信的写下输出结果:
-
//"定时器开始啦"
-
//"马上执行for循环啦"
-
//"执行then函数啦"
-
//"代码执行结束"复制代码
去chrome上验证下,结果完全不对,瞬间懵了,说好的一行一行执行的呢?
我们真的要彻底弄明白javascript的执行机制了。
1.关于javascript
javascript是一门单线程语言,在最新的HTML5中提出了Web-Worker,但javascript是单线程这一核心仍未改变。所以一切javascript版的"多线程"都是用单线程模拟出来的,一切javascript多线程都是纸老虎!
2.javascript事件循环
既然js是单线程,那就像只有一个窗口的银行,客户需要排队一个一个办理业务,同理js任务也要一个一个顺序执行。如果一个任务耗时过长,那么后一个任务也必须等着。那么问题来了,假如我们想浏览新闻,但是新闻包含的超清图片加载很慢,难道我们的网页要一直卡着直到图片完全显示出来?因此聪明的程序员将任务分为两类:
- 同步任务
- 异步任务
当我们打开网站时,网页的渲染过程就是一大堆同步任务,比如页面骨架和页面元素的渲染。而像加载图片音乐之类占用资源大耗时久的任务,就是异步任务。关于这部分有严格的文字定义,但本文的目的是用最小的学习成本彻底弄懂执行机制,所以我们用导图来说明:
导图要表达的内容用文字来表述的话:
- 同步和异步任务分别进入不同的执行"场所",同步的进入主线程,异步的进入Event Table并注册函数。
- 当指定的事情完成时,Event Table会将这个函数移入Event Queue。
- 主线程内的任务执行完毕为空,会去Event Queue读取对应的函数,进入主线程执行。
- 上述过程会不断重复,也就是常说的Event Loop(事件循环)。
我们不禁要问了,那怎么知道主线程执行栈为空啊?js引擎存在monitoring process进程,会持续不断的检查主线程执行栈是否为空,一旦为空,就会去Event Queue那里检查是否有等待被调用的函数。
说了这么多文字,不如直接一段代码更直白:
-
let data = [];
-
$.ajax({
-
url:www.javascript.com,
-
data:data,
-
success:() => {
-
console.log('发送成功!');
-
}
-
})
-
console.log('代码执行结束');复制代码
上面是一段简易的ajax
请求代码:
- ajax进入Event Table,注册回调函数
success
。 - 执行
console.log('代码执行结束')
。 - ajax事件完成,回调函数
success
进入Event Queue。 - 主线程从Event Queue读取回调函数
success
并执行。
相信通过上面的文字和代码,你已经对js的执行顺序有了初步了解。接下来我们来研究进阶话题:setTimeout。
3.又爱又恨的setTimeout
大名鼎鼎的setTimeout
无需再多言,大家对他的第一印象就是异步可以延时执行,我们经常这么实现延时3秒执行:
-
setTimeout(() => {
-
console.log('延时3秒');
-
},3000)复制代码
渐渐的setTimeout
用的地方多了,问题也出现了,有时候明明写的延时3秒,实际却5,6秒才执行函数,这又咋回事啊?
先看一个例子:
-
setTimeout(() => {
-
task();
-
},3000)
-
console.log('执行console');复制代码
根据前面我们的结论,setTimeout
是异步的,应该先执行console.log
这个同步任务,所以我们的结论是:
-
//执行console
-
//task()复制代码
去验证一下,结果正确!
然后我们修改一下前面的代码:
-
setTimeout(() => {
-
task()
-
},3000)
-
sleep(10000000)复制代码
乍一看其实差不多嘛,但我们把这段代码在chrome执行一下,却发现控制台执行task()
需要的时间远远超过3秒,说好的延时三秒,为啥现在需要这么长时间啊?
这时候我们需要重新理解setTimeout
的定义。我们先说上述代码是怎么执行的:
task()
进入Event Table并注册,计时开始。- 执行
sleep
函数,很慢,非常慢,计时仍在继续。 - 3秒到了,计时事件
timeout
完成,task()
进入Event Queue,但是sleep
也太慢了吧,还没执行完,只好等着。 sleep
终于执行完了,task()
终于从Event Queue进入了主线程执行。
上述的流程走完,我们知道setTimeout
这个函数,是经过指定时间后,把要执行的任务(本例中为task()
)加入到Event Queue中,又因为是单线程任务要一个一个执行,如果前面的任务需要的时间太久,那么只能等着,导致真正的延迟时间远远大于3秒。
我们还经常遇到setTimeout(fn,0)
这样的代码,0秒后执行又是什么意思呢?是不是可以立即执行呢?
答案是不会的,setTimeout(fn,0)
的含义是,指定某个任务在主线程最早可得的空闲时间执行,意思就是不用再等多少秒了,只要主线程执行栈内的同步任务全部执行完成,栈为空就马上执行。举例说明:
-
//代码1
-
console.log('先执行这里');
-
setTimeout(() => {
-
console.log('执行啦')
-
},0);复制代码
-
//代码2
-
console.log('先执行这里');
-
setTimeout(() => {
-
console.log('执行啦')
-
},3000);复制代码
代码1的输出结果是:
-
//先执行这里
-
//执行啦复制代码
代码2的输出结果是:
-
//先执行这里
-
// ... 3s later
-
// 执行啦复制代码
关于setTimeout
要补充的是,即便主线程为空,0毫秒实际上也是达不到的。根据HTML的标准,最低是4毫秒。有兴趣的同学可以自行了解。
4.又恨又爱的setInterval
上面说完了setTimeout
,当然不能错过它的孪生兄弟setInterval
。他俩差不多,只不过后者是循环的执行。对于执行顺序来说,setInterval
会每隔指定的时间将注册的函数置入Event Queue,如果前面的任务耗时太久,那么同样需要等待。
唯一需要注意的一点是,对于setInterval(fn,ms)
来说,我们已经知道不是每过ms
秒会执行一次fn
,而是每过ms
秒,会有fn
进入Event Queue。一旦setInterval
的回调函数fn
执行时间超过了延迟时间ms
,那么就完全看不出来有时间间隔了。这句话请读者仔细品味。
5.Promise与process.nextTick(callback)
传统的定时器我们已经研究过了,接着我们探究Promise
与process.nextTick(callback)
的表现。
Promise
的定义和功能本文不再赘述,不了解的读者可以学习一下阮一峰老师的Promise。而process.nextTick(callback)
类似node.js版的"setTimeout",在事件循环的下一次循环中调用 callback 回调函数。
我们进入正题,除了广义的同步任务和异步任务,我们对任务有更精细的定义:
- macro-task(宏任务):包括整体代码script,setTimeout,setInterval
- micro-task(微任务):Promise,process.nextTick
不同类型的任务会进入对应的Event Queue,比如setTimeout
和setInterval
会进入相同的Event Queue。
事件循环的顺序,决定js代码的执行顺序。进入整体代码(宏任务)后,开始第一次循环。接着执行所有的微任务。然后再次从宏任务开始,找到其中一个任务队列执行完毕,再执行所有的微任务。听起来有点绕,我们用文章最开始的一段代码说明:
-
setTimeout(function() {
-
console.log('setTimeout');
-
})
-
new Promise(function(resolve) {
-
console.log('promise');
-
}).then(function() {
-
console.log('then');
-
})
-
console.log('console');复制代码
- 这段代码作为宏任务,进入主线程。
- 先遇到
setTimeout
,那么将其回调函数注册后分发到宏任务Event Queue。(注册过程与上同,下文不再描述) - 接下来遇到了
Promise
,new Promise
立即执行,then
函数分发到微任务Event Queue。 - 遇到
console.log()
,立即执行。 - 好啦,整体代码script作为第一个宏任务执行结束,看看有哪些微任务?我们发现了
then
在微任务Event Queue里面,执行。 - ok,第一轮事件循环结束了,我们开始第二轮循环,当然要从宏任务Event Queue开始。我们发现了宏任务Event Queue中
setTimeout
对应的回调函数,立即执行。 - 结束。
事件循环,宏任务,微任务的关系如图所示:
我们来分析一段较复杂的代码,看看你是否真的掌握了js的执行机制:
-
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')
-
})
-
})复制代码
第一轮事件循环流程分析如下:
- 整体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 | 微任务Event Queue |
---|---|
setTimeout1 | process1 |
setTimeout2 | then1 |
-
上表是第一轮事件循环宏任务结束时各Event Queue的情况,此时已经输出了1和7。
-
我们发现了
process1
和then1
两个微任务。 - 执行
process1
,输出6。 - 执行
then1
,输出8。
好了,第一轮事件循环正式结束,这一轮的结果是输出1,7,6,8。那么第二轮时间循环从setTimeout1
宏任务开始:
- 首先输出2。接下来遇到了
process.nextTick()
,同样将其分发到微任务Event Queue中,记为process2
。new Promise
立即执行输出4,then
也分发到微任务Event Queue中,记为then2
。
宏任务Event Queue | 微任务Event Queue |
---|---|
setTimeout2 | process2 |
then2 |
- 第二轮事件循环宏任务结束,我们发现有
process2
和then2
两个微任务可以执行。 - 输出3。
- 输出5。
- 第二轮事件循环结束,第二轮输出2,4,3,5。
- 第三轮事件循环开始,此时只剩setTimeout2了,执行。
- 直接输出9。
- 将
process.nextTick()
分发到微任务Event Queue中。记为process3
。 - 直接执行
new Promise
,输出11。 - 将
then
分发到微任务Event Queue中,记为then3
。
宏任务Event Queue | 微任务Event Queue |
---|---|
process3 | |
then3 |
- 第三轮事件循环宏任务执行结束,执行两个微任务
process3
和then3
。 - 输出10。
- 输出12。
- 第三轮事件循环结束,第三轮输出9,11,10,12。
整段代码,共进行了三次事件循环,完整的输出为1,7,6,8,2,4,3,5,9,11,10,12。
(请注意,node环境下的事件监听依赖libuv与前端环境不完全相同,输出顺序可能会有误差)
-
process.nextTick(function(){
-
console.log(7);
-
});
-
new Promise(function(resolve){
-
console.log(3);
-
resolve();
-
console.log(4);
-
}).then(function(){
-
console.log(5);
-
});
-
process.nextTick(function(){
-
console.log(8);
-
});
这段代码运行结果是3,4,7,8,5
process.nextTick和Promise都是Microtasks,为什么process.nextTick会先执行?
rocess.nextTick 永远大于 promise.then,原因其实很简单。。。在Node中,_tickCallback在每一次执行完TaskQueue中的一个任务后被调用,而这个_tickCallback中实质上干了两件事:
1.nextTickQueue中所有任务执行掉(长度最大1e4,Node版本v6.9.1)
2.第一步执行完后执行_runMicrotasks函数,执行microtask中的部分(promise.then注册的回调)
所以很明显 process.nextTick > promise.then
6.写在最后
(1)js的异步
我们从最开头就说javascript是一门单线程语言,不管是什么新框架新语法糖实现的所谓异步,其实都是用同步的方法去模拟的,牢牢把握住单线程这点非常重要。
(2)事件循环Event Loop
事件循环是js实现异步的一种方法,也是js的执行机制。
(3)javascript的执行和运行
执行和运行有很大的区别,javascript在不同的环境下,比如node,浏览器,Ringo等等,执行方式是不同的。而运行大多指javascript解析引擎,是统一的。
(4)setImmediate
微任务和宏任务还有很多种类,比如setImmediate
等等,执行都是有共同点的,有兴趣的同学可以自行了解。
(5)最后的最后
- javascript是一门单线程语言
- Event Loop是javascript的执行机制
牢牢把握两个基本点,以认真学习javascript为中心,早日实现成为前端高手的伟大梦想!
续集:
宏任务一般是:包括整体代码script,setTimeout,setInterval。
微任务:Promise,process.nextTick。
a主线任务
异步队列,先执行:
b微任务,
c最宏任务。
27.前端跨域的方式
使用jsonp跨域,因为script标签引入的js是不受同源策略的限制,通过script标签引入一个js或者是一个其他后缀形式(如php,jsp等)的文件,此时文件返回一个JS函数的调用
通过cors跨域,实现cors通信的关键是服务器,只要服务器实现cors接口,就可以跨域
<script type="text/javascript">
var xhr = new XMLHttpRequest();
xhr.open("GET", "http://segmentfault.com/u/trigkit4/",true);
xhr.send();
</script>
1
2
3
4
5
反向代理跨域,反向代理指的是在前端的服务器环境中, 短暂的开启一个后端服务器, 由后端服务器进行数据请求, 然后在将结果返回给前端
再续eventloop事件:
前言
Event Loop
即事件循环,是指浏览器或Node
的一种解决javaScript
单线程运行时不会阻塞的一种机制,也就是我们经常使用异步的原理。
为啥要弄懂Event Loop
-
是要增加自己技术的深度,也就是懂得
JavaScript
的运行机制。 -
现在在前端领域各种技术层出不穷,掌握底层原理,可以让自己以不变,应万变。
-
应对各大互联网公司的面试,懂其原理,题目任其发挥。
Event Loop
在JavaScript
中,任务被分为两种,一种宏任务(MacroTask
)也叫Task
,一种叫微任务(MicroTask
)。
MacroTask(宏任务)
script
全部代码、setTimeout
、setInterval
、setImmediate
(浏览器暂时不支持,只有IE10支持,具体可见MDN
)、I/O
、UI Rendering
。
MicroTask(微任务)
Process.nextTick(Node独有)
、Promise
、Object.observe(废弃)
、MutationObserver
(具体使用方式查看这里)
浏览器中的Event Loop
Javascript
有一个 main thread
主线程和 call-stack
调用栈(执行栈),所有的任务都会被放到调用栈等待主线程执行。
JS调用栈
JS调用栈采用的是后进先出的规则,当函数执行的时候,会被添加到栈的顶部,当执行栈执行完成后,就会从栈顶移出,直到栈内被清空。
同步任务和异步任务
Javascript
单线程任务被分为同步任务和异步任务,同步任务会在调用栈中按照顺序等待主线程依次执行,异步任务会在异步任务有了结果后,将注册的回调函数放入任务队列中等待主线程空闲的时候(调用栈被清空),被读取到栈内等待主线程的执行。
任务队列Task Queue
,即队列,是一种先进先出的一种数据结构。
事件循环的进程模型
- 选择当前要执行的任务队列,选择任务队列中最先进入的任务,如果任务队列为空即
null
,则执行跳转到微任务(MicroTask
)的执行步骤。 - 将事件循环中的任务设置为已选择任务。
- 执行任务。
- 将事件循环中当前运行任务设置为null。
- 将已经运行完成的任务从任务队列中删除。
- microtasks步骤:进入microtask检查点。
- 更新界面渲染。
- 返回第一步。
执行进入microtask检查点时,用户代理会执行以下步骤:
- 设置microtask检查点标志为true。
- 当事件循环
microtask
执行不为空时:选择一个最先进入的microtask
队列的microtask
,将事件循环的microtask
设置为已选择的microtask
,运行microtask
,将已经执行完成的microtask
为null
,移出microtask
中的microtask
。 - 清理IndexDB事务
- 设置进入microtask检查点的标志为false。
上述可能不太好理解,下图是我做的一张图片。
执行栈在执行完同步任务后,查看执行栈是否为空,如果执行栈为空,就会去检查微任务(microTask
)队列是否为空,如果为空的话,就执行Task
(宏任务),否则就一次性执行完所有微任务。
每次单个宏任务执行完毕后,检查微任务(microTask
)队列是否为空,如果不为空的话,会按照先入先出的规则全部执行完微任务(microTask
)后,设置微任务(microTask
)队列为null
,然后再执行宏任务,如此循环。
举个例子
console.log('script start');
setTimeout(function() {
console.log('setTimeout');
}, 0);
Promise.resolve().then(function() {
console.log('promise1');
}).then(function() {
console.log('promise2');
});
console.log('script end');
复制代码
首先我们划分几个分类:
第一次执行:
Tasks:run script、 setTimeout callback
Microtasks:Promise then
JS stack: script
Log: script start、script end。
复制代码
执行同步代码,将宏任务(Tasks
)和微任务(Microtasks
)划分到各自队列中。
第二次执行:
Tasks:run script、 setTimeout callback
Microtasks:Promise2 then
JS stack: Promise2 callback
Log: script start、script end、promise1、promise2
复制代码
执行宏任务后,检测到微任务(Microtasks
)队列中不为空,执行Promise1
,执行完成Promise1
后,调用Promise2.then
,放入微任务(Microtasks
)队列中,再执行Promise2.then
。
第三次执行:
Tasks:setTimeout callback
Microtasks:
JS stack: setTimeout callback
Log: script start、script end、promise1、promise2、setTimeout
复制代码
当微任务(Microtasks
)队列中为空时,执行宏任务(Tasks
),执行setTimeout callback
,打印日志。
第四次执行:
Tasks:setTimeout callback
Microtasks:
JS stack:
Log: script start、script end、promise1、promise2、setTimeout
复制代码
清空Tasks队列和JS stack
。
以上执行帧动画可以查看Tasks, microtasks, queues and schedules
或许这张图也更好理解些。
再举个例子
console.log('script start')
async function async1() {
await async2()
console.log('async1 end')
}
async function async2() {
console.log('async2 end')
}
async1()
setTimeout(function() {
console.log('setTimeout')
}, 0)
new Promise(resolve => {
console.log('Promise')
resolve()
})
.then(function() {
console.log('promise1')
})
.then(function() {
console.log('promise2')
})
console.log('script end')
复制代码
这里需要先理解async/await
。
async/await
在底层转换成了 promise
和 then
回调函数。
也就是说,这是 promise
的语法糖。
每次我们使用 await
, 解释器都创建一个 promise
对象,然后把剩下的 async
函数中的操作放到 then
回调函数中。async/await
的实现,离不开 Promise
。从字面意思来理解,async
是“异步”的简写,而 await
是 async wait
的简写可以认为是等待异步方法执行完成。
关于73以下版本和73版本的区别
- 在老版本版本以下,先执行
promise1
和promise2
,再执行async1
。 - 在73版本,先执行
async1
再执行promise1
和promise2
。
主要原因是因为在谷歌(金丝雀)73版本中更改了规范,如下图所示:
- 区别在于
RESOLVE(thenable)
和之间的区别Promise.resolve(thenable)
。
在老版本中
- 首先,传递给
await
的值被包裹在一个Promise
中。然后,处理程序附加到这个包装的Promise
,以便在Promise
变为fulfilled
后恢复该函数,并且暂停执行异步函数,一旦promise
变为fulfilled
,恢复异步函数的执行。 - 每个
await
引擎必须创建两个额外的 Promise(即使右侧已经是一个Promise
)并且它需要至少三个microtask
队列ticks
(tick
为系统的相对时间单位,也被称为系统的时基,来源于定时器的周期性中断(输出脉冲),一次中断表示一个tick
,也被称做一个“时钟滴答”、时标。)。
引用贺老师知乎上的一个例子
async function f() {
await p
console.log('ok')
}
复制代码
简化理解为:
function f() {
return RESOLVE(p).then(() => {
console.log('ok')
})
}
复制代码
- 如果
RESOLVE(p)
对于p
为promise
直接返回p
的话,那么p
的then
方法就会被马上调用,其回调就立即进入job
队列。 - 而如果
RESOLVE(p)
严格按照标准,应该是产生一个新的promise
,尽管该promise
确定会resolve
为p
,但这个过程本身是异步的,也就是现在进入job
队列的是新promise
的resolve
过程,所以该promise
的then
不会被立即调用,而要等到当前job
队列执行到前述resolve
过程才会被调用,然后其回调(也就是继续await
之后的语句)才加入job
队列,所以时序上就晚了。
谷歌(金丝雀)73版本中
- 使用对
PromiseResolve
的调用来更改await
的语义,以减少在公共awaitPromise
情况下的转换次数。 - 如果传递给
await
的值已经是一个Promise
,那么这种优化避免了再次创建Promise
包装器,在这种情况下,我们从最少三个microtick
到只有一个microtick
。
详细过程:
73以下版本
- 首先,打印
script start
,调用async1()
时,返回一个Promise
,所以打印出来async2 end
。 - 每个
await
,会新产生一个promise
,但这个过程本身是异步的,所以该await
后面不会立即调用。 - 继续执行同步代码,打印
Promise
和script end
,将then
函数放入微任务队列中等待执行。 - 同步执行完成之后,检查微任务队列是否为
null
,然后按照先入先出规则,依次执行。 - 然后先执行打印
promise1
,此时then
的回调函数返回undefinde
,此时又有then
的链式调用,又放入微任务队列中,再次打印promise2
。 - 再回到
await
的位置执行返回的Promise
的resolve
函数,这又会把resolve
丢到微任务队列中,打印async1 end
。 - 当微任务队列为空时,执行宏任务,打印
setTimeout
。
谷歌(金丝雀73版本)
- 如果传递给
await
的值已经是一个Promise
,那么这种优化避免了再次创建Promise
包装器,在这种情况下,我们从最少三个microtick
到只有一个microtick
。 - 引擎不再需要为
await
创造throwaway Promise
- 在绝大部分时间。 - 现在
promise
指向了同一个Promise
,所以这个步骤什么也不需要做。然后引擎继续像以前一样,创建throwaway Promise
,安排PromiseReactionJob
在microtask
队列的下一个tick
上恢复异步函数,暂停执行该函数,然后返回给调用者。
具体详情查看(这里)。
NodeJS的Event Loop
Node
中的Event Loop
是基于libuv
实现的,而libuv
是 Node
的新跨平台抽象层,libuv使用异步,事件驱动的编程方式,核心是提供i/o
的事件循环和异步回调。libuv的API
包含有时间,非阻塞的网络,异步文件操作,子进程等等。 Event Loop
就是在libuv
中实现的。
Node
的Event loop
一共分为6个阶段,每个细节具体如下:
timers
: 执行setTimeout
和setInterval
中到期的callback
。pending callback
: 上一轮循环中少数的callback
会放在这一阶段执行。idle, prepare
: 仅在内部使用。poll
: 最重要的阶段,执行pending callback
,在适当的情况下回阻塞在这个阶段。check
: 执行setImmediate
(setImmediate()
是将事件插入到事件队列尾部,主线程和事件队列的函数执行完成之后立即执行setImmediate
指定的回调函数)的callback
。close callbacks
: 执行close
事件的callback
,例如socket.on('close'[,fn])
或者http.server.on('close, fn)
。
具体细节如下:
timers
执行setTimeout
和setInterval
中到期的callback
,执行这两者回调需要设置一个毫秒数,理论上来说,应该是时间一到就立即执行callback回调,但是由于system
的调度可能会延时,达不到预期时间。
以下是官网文档解释的例子:
const fs = require('fs');
function someAsyncOperation(callback) {
// Assume this takes 95ms to complete
fs.readFile('/path/to/file', callback);
}
const timeoutScheduled = Date.now();
setTimeout(() => {
const delay = Date.now() - timeoutScheduled;
console.log(`${delay}ms have passed since I was scheduled`);
}, 100);
// do someAsyncOperation which takes 95 ms to complete
someAsyncOperation(() => {
const startCallback = Date.now();
// do something that will take 10ms...
while (Date.now() - startCallback < 10) {
// do nothing
}
});
复制代码
当进入事件循环时,它有一个空队列(fs.readFile()
尚未完成),因此定时器将等待剩余毫秒数,当到达95ms时,fs.readFile()
完成读取文件并且其完成需要10毫秒的回调被添加到轮询队列并执行。
当回调结束时,队列中不再有回调,因此事件循环将看到已达到最快定时器的阈值,然后回到timers阶段以执行定时器的回调。
在此示例中,您将看到正在调度的计时器与正在执行的回调之间的总延迟将为105毫秒。
以下是我测试时间:
pending callbacks
此阶段执行某些系统操作(例如TCP错误类型)的回调。 例如,如果TCP socket ECONNREFUSED
在尝试connect时receives,则某些* nix系统希望等待报告错误。 这将在pending callbacks
阶段执行。
poll
该poll阶段有两个主要功能:
- 执行
I/O
回调。 - 处理轮询队列中的事件。
当事件循环进入poll
阶段并且在timers
中没有可以执行定时器时,将发生以下两种情况之一
- 如果
poll
队列不为空,则事件循环将遍历其同步执行它们的callback
队列,直到队列为空,或者达到system-dependent
(系统相关限制)。
如果poll
队列为空,则会发生以下两种情况之一
-
如果有
setImmediate()
回调需要执行,则会立即停止执行poll
阶段并进入执行check
阶段以执行回调。 -
如果没有
setImmediate()
回到需要执行,poll阶段将等待callback
被添加到队列中,然后立即执行。
当然设定了 timer 的话且 poll 队列为空,则会判断是否有 timer 超时,如果有的话会回到 timer 阶段执行回调。
check
此阶段允许人员在poll阶段完成后立即执行回调。
如果poll
阶段闲置并且script
已排队setImmediate()
,则事件循环到达check阶段执行而不是继续等待。
setImmediate()
实际上是一个特殊的计时器,它在事件循环的一个单独阶段运行。它使用libuv API
来调度在poll
阶段完成后执行的回调。
通常,当代码被执行时,事件循环最终将达到poll
阶段,它将等待传入连接,请求等。
但是,如果已经调度了回调setImmediate()
,并且轮询阶段变为空闲,则它将结束并且到达check
阶段,而不是等待poll
事件。
console.log('start')
setTimeout(() => {
console.log('timer1')
Promise.resolve().then(function() {
console.log('promise1')
})
}, 0)
setTimeout(() => {
console.log('timer2')
Promise.resolve().then(function() {
console.log('promise2')
})
}, 0)
Promise.resolve().then(function() {
console.log('promise3')
})
console.log('end')
复制代码
如果node
版本为v11.x
, 其结果与浏览器一致。
start
end
promise3
timer1
promise1
timer2
promise2
复制代码
具体详情可以查看《又被node的eventloop坑了,这次是node的锅》。
如果v10版本上述结果存在两种情况:
- 如果time2定时器已经在执行队列中了
start
end
promise3
timer1
timer2
promise1
promise2
复制代码
- 如果time2定时器没有在执行对列中,执行结果为
start
end
promise3
timer1
promise1
timer2
promise2
复制代码
具体情况可以参考poll
阶段的两种情况。
从下图可能更好理解:
setImmediate() 的setTimeout()的区别
setImmediate
和setTimeout()
是相似的,但根据它们被调用的时间以不同的方式表现。
setImmediate()
设计用于在当前poll
阶段完成后check阶段执行脚本 。setTimeout()
安排在经过最小(ms)后运行的脚本,在timers
阶段执行。
举个例子
setTimeout(() => {
console.log('timeout');
}, 0);
setImmediate(() => {
console.log('immediate');
});
复制代码
执行定时器的顺序将根据调用它们的上下文而有所不同。 如果从主模块中调用两者,那么时间将受到进程性能的限制。
其结果也不一致
如果在I / O
周期内移动两个调用,则始终首先执行立即回调:
const fs = require('fs');
fs.readFile(__filename, () => {
setTimeout(() => {
console.log('timeout');
}, 0);
setImmediate(() => {
console.log('immediate');
});
});
复制代码
其结果可以确定一定是immediate => timeout
。
主要原因是在I/O阶段
读取文件后,事件循环会先进入poll
阶段,发现有setImmediate
需要执行,会立即进入check
阶段执行setImmediate
的回调。
然后再进入timers
阶段,执行setTimeout
,打印timeout
。
┌───────────────────────────┐
┌─>│ timers │
│ └─────────────┬─────────────┘
│ ┌─────────────┴─────────────┐
│ │ pending callbacks │
│ └─────────────┬─────────────┘
│ ┌─────────────┴─────────────┐
│ │ idle, prepare │
│ └─────────────┬─────────────┘ ┌───────────────┐
│ ┌─────────────┴─────────────┐ │ incoming: │
│ │ poll │<─────┤ connections, │
│ └─────────────┬─────────────┘ │ data, etc. │
│ ┌─────────────┴─────────────┐ └───────────────┘
│ │ check │
│ └─────────────┬─────────────┘
│ ┌─────────────┴─────────────┐
└──┤ close callbacks │
└───────────────────────────┘
复制代码
Process.nextTick()
process.nextTick()
虽然它是异步API的一部分,但未在图中显示。这是因为process.nextTick()
从技术上讲,它不是事件循环的一部分。
process.nextTick()
方法将callback
添加到next tick
队列。 一旦当前事件轮询队列的任务全部完成,在next tick
队列中的所有callbacks
会被依次调用。
换种理解方式:
- 当每个阶段完成后,如果存在
nextTick
队列,就会清空队列中的所有回调函数,并且优先于其他microtask
执行。
例子
let bar;
setTimeout(() => {
console.log('setTimeout');
}, 0)
setImmediate(() => {
console.log('setImmediate');
})
function someAsyncApiCall(callback) {
process.nextTick(callback);
}
someAsyncApiCall(() => {
console.log('bar', bar); // 1
});
bar = 1;
复制代码
在NodeV10中上述代码执行可能有两种答案,一种为:
bar 1
setTimeout
setImmediate
复制代码
另一种为:
bar 1
setImmediate
setTimeout
复制代码
无论哪种,始终都是先执行process.nextTick(callback)
,打印bar 1