JavaScript运行机制

2019/04/10 10:10
阅读数 4

前言

本文要讲的是,浏览器读一个script代码的流程是什么,遇到异步代码会如何处理,宏观任务和微观任务如何处理。

开始前先来看几个概念。

栈(后进先出)

首先要说一个栈模型,函数的调用形成了栈帧。

function f1() {     
    f2();
}
function f2() {}
f1();

例如这段代码,调用 <code>f1</code> 时,创建第一帧;<code>f1</code> 调用 <code>f2</code> 时,创建第二帧。第二帧压在第一帧之上,当 <code>f2</code> 运行完成,此时最上层第二帧弹出栈,当 <code>f1</code> 运行完成,此时最上层第一帧也弹出栈,栈就空了。也就是常说的后进先出。

<img style="width: 200px;" src="https://user-gold-cdn.xitu.io/2020/2/21/17067522f7d6e144?w=440&h=506&f=png&s=18175" />

这个栈也就是常说的 执行栈,执行的是任务队列里的任务。

队列(先进先出)

然后说一下队列。队列中放着任务。

如果有新的任务(例如用户触发了点击事件),会加入队列,排在后面。

队列里的任务会放在执行栈中执行。

<img style="width: 400px;" src="https://user-gold-cdn.xitu.io/2020/2/21/1706766182fd4734?w=830&h=330&f=png&s=20276" />

队列有两种:宏观任务队列和微观任务队列。
分别放着两种任务:宏观任务和微观任务。

宏观任务(Task,或者叫MacroTask)

宿主发起的任务。

如 包含代码的script, setTimeout, setInterval, setImmediate, requestAnimationFrame, I/O, UI rendering

微观任务(MicroTask)

JavaScript引擎发起的任务为微观任务。微任务相当于加急的任务,时间循环会优先处理完微任务。

如 process.nextTick, Promises, Object.observe, MutationObserver

浏览器中的事件循环(Event Loop)

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

<img style="width: 500px;" src="https://user-gold-cdn.xitu.io/2020/2/25/1707ba842b193202?w=601&h=527&f=png&s=55848" />

执行栈(stack)执行过程中如果遇到异步代码,会将其移除本次执行,加入到其他线程中,处理完成后该线程会把任务添加到对应的任务队列队尾。例如setTime延迟结束后会被添加到宏观任务队列,promise执行完成后会被添加到微观任务队列。

事件循环,宏任务,微任务的关系如图所示:

<img style="width: 500px;" src="https://user-gold-cdn.xitu.io/2020/2/29/1708ca06afcdd311?w=912&h=968&f=png&s=65325" />

script标签的整块代码是执行栈的第一个执行任务。

下面来看一段代码

测试:宏任务微任务执行顺序

setTimeout(() => console.log(1))

console.log(2);

new Promise((resolve, reject) => {
    console.log(3)
    resolve();
}).then(() => console.log(4))

console.log(5)

执行过程:

  • 执行第一个宏任务(整块代码)
  • 遇到setTimeout,跳过(延迟结束后被添加到宏观任务队列)
  • 打印 2
  • new promise属于同步代码,打印 3,then属于异步,跳过promise.then(完成后被添加到微观任务队列)
  • 打印 5
  • 执行结束
  • 有可执行的微任务,开始微任务
  • 打印4
  • 执行结束
  • 没有可执行的微任务,开始宏任务
  • 打印1
  • 执行结束
  • 没有微任务,没有宏任务。

所以执行结果:2 3 5 4 1

测试:setTimeout第二个参数是最小延迟时间

var t = +new Date();

setTimeout(() => {
    console.log('timer 2秒,实际时间为3秒');
}, 2000)

setTimeout(() => {
    console.log('timer 1秒,实际时间为3秒');
}, 1000)

while (+new Date() - t < 3000) {} // 延迟3秒

解析:第一秒时候,第二个setTimeout插入宏观任务队列;第二秒时,第一个setTimeout插入宏观任务队列;第三秒

  • 第一秒:第二个setTimeout插入宏观任务队列;
  • 第二秒:第一个setTimeout插入宏观任务队列;
  • 第三秒:代码执行结束;
  • 没有可执行微观任务,执行宏观任务 输出 'timer 1秒,实际时间为3秒',代码执行结束;
  • 没有可执行微观任务,执行宏观任务 输出 'timer 2秒,实际时间为3秒',代码执行结束;

可见setTimeout延迟结束后立即插入宏观任务队列。

所以执行结果为:
timer 1秒,实际时间为3秒
timer 2秒,实际时间为3秒

测试:宏任务在微任务之前完成

setTimeout(() => console.log(1))

fetch('https://deployment.whosmeya.com/api/getok')
    .then(() => console.log(2))

var t = +new Date();
while (+new Date() - t < 2000) {} // 延迟两秒

解析:虽然宏观任务setTimeout在微观任务promise之前完成,第一次宏任务(整块代码)执行结束后,监测到有可执行微观任务,所以先执行微观任务。

所以执行结果:2 1

测试:宏任务包含微任务

setTimeout(() => console.log(1))

new Promise(function (resolve, reject) {
    setTimeout(() => resolve())
}).then(() => console.log(2))

解析:第一个宏任务(代码块)执行完成后,宏观任务队列会有两个宏观任务,所以第一个setTime先执行。 执行栈的任务执行顺序为:代码块,第一个setTimeout,第二个setTimeout,promise.then。

所以执行结果为:1 2

总结

  1. javascript是单线程的意思是 主线程为单线程,除此之外还拥有渲染线程,事件线程等。
  2. event loop 总是不停的监听任务队列,有任务就放进执行栈。
  3. 微观任务就像加急任务,总是优先全部执行。
  4. 执行栈遇到异步代码会给其他线程执行,执行完成后会被该线程插入对应任务队列。

参考

原文出处:https://www.cnblogs.com/whosmeya/p/12557622.html

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部