Javascript之Event Loop

先看段代码:

console.log(1);

setTimeout(function () {
    console.log(2);

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

function fn() {
    console.log(6);
    setTimeout(function () {
        console.log(7);
    }, 50);
}

new Promise(function (resolve, reject) {
    console.log(8);
    resolve();
    console.log(9);
}).then(function () {
    console.log(10);
});

fn();

console.log(11);

// 以下代码需要在 node 环境中执行
process.nextTick(function () {
    console.log(12);
});

setImmediate(function () {
    console.log(13);
});

思考一下,能给出准确的输出顺序吗?

下面我们一个一个的来了解 Event Loop 相关的知识点,最后再一步一步分析出本段代码最后的输出顺序。

JavaScript是单线程

首先我们先了解下进程和线程的概念和关系:

  • 进程: 运行的程序就是一个进程,比如你正在运行的浏览器,它会有一个进程。
  • 线程: 程序中独立运行的代码段。一个进程 由单个或多个 线程 组成,线程是负责执行代码的。

我们都知道 JavaScript 是单线程的,那么既然有单线程就有多线程,首先看看单线程与多线程的区别:

  • 单线程: 从头执行到尾,一行一行执行,如果其中一行代码报错,那么剩下代码将不再执行。同时容易代码阻塞。
  • 多线程: 代码运行的环境不同,各线程独立,互不影响,避免阻塞。

那为什么JavaScript是单线程的呢?

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

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

为了利用多核 CPU 的计算能力,HTML5 提出 Web Worker 标准,允许 JavaScript 脚本创建多个线程,但是子线程完全受主线程控制,且不得操作 DOM。所以,这个新标准并没有改变 JavaScript 单线程的本质。

执行栈、任务队列

上图中,主线程运行的时候,产生堆(heap)和栈(stack),栈中的代码调用各种外部API,它们在"任务队列"中加入各种事件(DOM Event,ajax,setTimeout...)。只要栈中的代码执行完毕,主线程就会去读取任务队列,依次执行那些事件所对应的回调函数。

堆(heap):

对象被分配在一个堆中,即用以表示一个大部分非结构化的内存区域。

执行栈(stack):

运行同步代码。执行栈中的代码(同步任务),总是在读取"任务队列"(异步任务)之前执行。

任务队列(callback queue):

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

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

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

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

同步任务、异步任务、宏任务、微任务

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

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

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

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

具体来说,异步执行的运行机制如下(同步执行也是如此,因为它可以被视为没有异步任务的异步执行):

(1)所有同步任务都在主线程上执行,形成一个"执行栈"(execution context stack);

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

(3)一旦"执行栈"中的所有同步任务执行完毕,系统就会取出"任务队列"中事件所对应的回调函数进入"执行栈",开始执行;

(4)主线程不断重复上面的第三步。

除了广义上的定义,我们可以将任务进行更精细的定义,分为宏任务与微任务:

  • 宏任务(macro-task): 包括整体代码script,setTimeout,setInterval,ajax,dom操作
  • 微任务(micro-task): Promise

具体来说,宏任务与微任务执行的运行机制如下:

(1)首先,将"执行栈"最开始的所有同步代码(宏任务)执行完成;

(2)检查是否有微任务,如有则执行所有的微任务;

(3)取出"任务队列"中事件所对应的回调函数(宏任务)进入"执行栈"并执行完成;

(4)再检查是否有微任务,如有则执行所有的微任务;

(5)主线程不断重复上面的(3)(4)步。

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

setTimeout()、setInterval()

setTimeout() 和 setInterval() 这两个函数,它们的内部运行机制完全一样,区别在于前者指定的代码是一次性执行,后者则为反复执行。

setTimeout() 和 setInterval() 产生的任务是 异步任务,也属于 宏任务

setTimeout() 接受两个参数,第一个是回调函数,第二个是推迟执行的毫秒数。setInterval() 接受两个参数,第一个是回调函数,第二个是反复执行的毫秒数。

如果将第二个参数设置为0或者不设置,意思 并不是立即执行,而是指定某个任务在主线程最早可得的空闲时间执行,也就是说,尽可能早得执行。它在"任务队列"的尾部添加一个事件,因此要等到同步任务和"任务队列"现有的事件都处理完,才会得到执行。

所以说,setTimeout() 和 setInterval() 第二个参数设置的时间并不是绝对的,它需要根据当前代码最终执行的时间来确定的,简单来说,如果当前代码执行的时间(如执行200ms)超出了推迟执行(setTimeout(fn, 100))或反复执行的时间(setInterval(fn, 100)),那么setTimeout(fn, 100) 和 setTimeout(fn, 0) 也就没有区别了,setInterval(fn, 100) 和 setInterval(fn, 0) 也就没有区别了。

Promise

Promise 相对来说就比较特殊了,在 new Promise() 中传入的回调函数是会 立即执行 的,但是它的 then() 方法是在 执行栈之后,任务队列之前 执行的,它属于 微任务

process.nextTick

process.nextTick 是 Node.js 提供的一个与"任务队列"有关的方法,它产生的任务是放在 执行栈的尾部,并不属于 宏任务微任务,因此它的任务 总是发生在所有异步任务之前。

setImmediate

setImmediate 是 Node.js 提供的另一个与"任务队列"有关的方法,它产生的任务追加到"任务队列"的尾部,它和 setTimeout(fn, 0) 很像,但优先级都是 setTimeout 优先于 setImmediate。

有时候,setTimeout 的执行顺序会在 setImmediate 的前面,有时候会在 setImmediate 的后面,这并不是 node.js 的 bug,这是因为虽然 setTimeout 第二个参数设置为0或者不设置,但是 setTimeout 源码中,会指定一个具体的毫秒数(node为1ms,浏览器为4ms),而由于当前代码执行时间受到执行环境的影响,执行时间有所起伏,如果当前执行的代码小于这个指定的值时,setTimeout 还没到推迟执行的时间,自然就先执行 setImmediate 了,如果当前执行的代码超过这个指定的值时,setTimeout 就会先于 setImmediate 执行。

优先级

通过上面的介绍,我们就可以得出一个代码执行的优先级:

同步代码(宏任务) > process.nextTick > Promise(微任务)> setTimeout(fn)、setInterval(fn)(宏任务)> setImmediate(宏任务)> setTimeout(fn, time)、setInterval(fn, time),其中time>0

代码解析

回到开头给出的代码,我们来一步一步解析:

运行"执行栈"中的代码:

console.log(1);

// setTimeout(function () { // 作为宏任务,暂不执行,放到任务队列中(1)
//  console.log(2);
//
//  new Promise(function (resolve, reject) {
//      console.log(3);
//      resolve();
//      console.log(4);
//  }).then(function () {
//      console.log(5);
//  });
// });

function fn() {
    console.log(6);
    //setTimeout(function () { // 作为宏任务,暂不执行,放到任务队列中(3)
    //  console.log(7);
    //}, 50);
}

new Promise(function (resolve, reject) {
    console.log(8);
    resolve();
    console.log(9);
})
// .then(function () { // 作为微任务,暂不执行
//  console.log(10);
// });

fn();

console.log(11);

process.nextTick(function () {
    console.log(12);
});

// setImmediate(function () { // 作为宏任务,暂不执行,放到任务队列中(2)
//  console.log(13);
// });

此时输出为:1 8 9 6 11 12

运行微任务:

new Promise(function (resolve, reject) {
    // console.log(8); // 已执行
    // resolve(); // 已执行
    // console.log(9); // 已执行
})
.then(function () {
    console.log(10);
});

此时输出为:10

读取"任务队列"的回调函数到"执行栈"

setTimeout(function () {
    console.log(2);

    new Promise(function (resolve, reject) {
        console.log(3);
        resolve();
        console.log(4);
    })
    //.then(function () { // 作为微任务,暂不执行
    //  console.log(5);
    //});
});

此时输出为:2 3 4

再运行微任务:

setTimeout(function () {
    // console.log(2); // 已执行

    new Promise(function (resolve, reject) {
        // console.log(3); // 已执行
        // resolve(); // 已执行
        // console.log(4); // 已执行
    })
    .then(function () {
        console.log(5);
    });
});

此时输出为:5

再读取"任务队列"的回调函数到"执行栈"

setImmediate(function () {
    console.log(13);
});

此时输出为:13

运行微任务:

再读取"任务队列"的回调函数到"执行栈"

// function fn() { // 已执行
    // console.log(6); // 已执行
    setTimeout(function () {
        console.log(7);
    }, 50);
// }

此时输出为:7

运行微任务:

综上,最终的输出顺序是:1 8 9 6 11 12 10 2 3 4 5 13 7

参考资料

posted @ 2018-04-16 17:14 laixiangran 阅读(...) 评论(...) 编辑 收藏