Node.js事件循环

来源:http://www.chinese-glasses.com 作者:Web前端 人气:105 发布时间:2020-04-22
摘要:时间: 2019-09-20阅读: 123标签: 循环 一、JavaScript单线程模型 JavaScript是单线程的,JavaScript只在一个线程上运行,但是浏览器是多线程的,典型的浏览器有如下线程: JavaScript引擎线程 GUI渲

时间: 2019-09-20阅读: 123标签: 循环

一、JavaScript单线程模型

JavaScript是单线程的,JavaScript只在一个线程上运行,但是浏览器是多线程的,典型的浏览器有如下线程:

  • JavaScript引擎线程
  • GUI渲染线程
  • 浏览器事件触发线程
  • 浏览器Http请求线程

说到Node.js的事件循环网上已经有了很多形形色色的文章来讲述其中的原理,说的大概都是一个意思,学习了一段时间,对Node.js事件循环有了一定的了解之后写一篇博客总结一下自己的学习成果。

二、JavaScript为什么是单线程的

  JavaScript之所以采用单线程 而不是多线程,由于作为浏览器脚本语言,主要用途是与用户互动,以及操作DOM(文档对象模型)和BOM(浏览器对象模型), 而多线程需要共享资源,多线程编程经࣡常面临锁、状态同步等问题。

  假定JavaScript同时有两个线程,这两个线程同时操作同一个DOM增删修改操作,这时浏览器应该以哪个线程操作为准?无疑会带来同步问题。

  既然JavaScript是单线程的,这就意味着,一次只能运行一个任务,其他任务都必须在后面排队等待
  为了利用多核CPU的计算能力,HTML5提出了Web Worker,它会在当 前JavaScript的执行主线程中利用Worker类新开辟一个额外的线程来加载和运行特定的JavaScript文件,但在HTML5 Web Worker中是不能操作DOM的,任何需要操作DOM的任务都需要委托给JavaScript主线程来执行,所以虽然引入HTML5 Web Worker,但仍然没有改变JavaScript单线程的本质。

事件循环

三、任务队列

Javascript有一个main thread 主进程和call-stack(一个调用堆栈),在对一个调用堆栈中的task处理的时候,其他的都要等着。当在执行过程中遇到一些类似于setTimeout等异步操作的时候,会交给浏览器的其他模块(以webkit为例,是webcore模块)进行处理,当到达setTimeout指定的延时执行的时间之后,task(回调函数)会放入到任务队列之中。一般不同的异步任务的回调函数会放入不同的任务队列之中。等到调用栈中所有task执行完毕之后,接着去执行任务队列之中的task(回调函数)。

在笔者看来事件与循环本身就是两个概念,事件是可以被控件识别的操作,如按下确定按钮,选择某个单选按钮或者复选框。每一种控件有自己可以识别的事件,如窗体的加载、单击、双击等事件,编辑框(文本框)的文本改变事件。

1.异步和同步

一般而言,操作分为:发出调用和得到结果两步

然而循环则是在GUI线程中包含有一个循环,然而这个循环对于开发者和用户来讲是看不见的,只有关闭了程序之后该循环才会结束。当用户触发了一个按钮事件之后,就会产生响应的事件,这些时间被加入到一个队列中,用户在前台不断的产生事件,然而后台也在不断的处理这些时间,在处理的时候被加入到一个队列中,由于主循环中循环的存在会挨个处理这些对应的事件。

同步

同步是指,发出调用,但无法立即得到结果,需要一直等待,直到返回结果。同步任务会进入主线程, 主线程后面任务必须要等当前任务执行完才能执行,从而导致主线程阻塞。

而对于JavaScript来讲的话由于JavaScript是单线程的,对于一个比较耗时的操作则是使用异步的方法解决(Ajax...)。对于不同的异步事件来也是由不同的线程各司其职来处理的。

异步

异步是指,调用之后,不能直接拿到结果,通过event loop事件处理机制,在Event Queue注册回调函数最终拿到结果(拿到结果中间的时间可以介入其他任务)。

Node.js中的事件循环

四、JavaScript如何工作的,首先要理解以下几个概念

  • JS Engine(JS引擎)
  • Runtime(运行上下文)
  • Call Stack(调用栈)
  • Event Loop(事件循环)
  • Callback(回调)

Node.js的事件循环与浏览器的事件循环还是有很大的区别的,当Node.js启动后,它会初始化事件轮询;处理已提供的输入脚本(或丢入REPL,本文不涉及到),它可能会调用一些异步的API函数调用,安排任务处理事件,或者调用process.nextTick(),然后开始处理事件循环。

1.JS Engine

JavaScript引擎就是用来执行JS代码的, 通过编译器将代码编译成可执行的机器码让计算机去执行(Java中的JVM虚拟机一样)。

常见的JavaScript虚拟机(一般也把虚拟机称为引擎):

  • Chakra(Microsoft Internet Explorer)
  • Nitro/JavaScript Core (Safari)
  • Carakan (Opera)
  • SpiderMonkey (Firefox)
  • V8 (Chrome, Chromium)

目前比较流行的就是V8引擎,Chrome浏览器和Node.js采用的引擎就是V8引擎。
引擎主要由堆(Memory Heap)和栈(Call Stack)组成

图片 1

headandstack.png

  • Heap(堆) - JS引擎中给对象分配的内存空间是放在堆中的
  • Stack(栈)- 这里存储着JavaScript正在执行的任务。每个任务被称为帧(stack of frames)。

主线程运行的时候,产生堆(heap)和栈(stack),栈中的代码调用个各种外部api。

有一点是非常明确的,事件循环同样运行在单线程环境下,JavaScript的事件循环是依靠于浏览器来实现的,然而Node.js则是依赖于Libuv来实现的。

2.RunTime (运行环境)

JS在浏览器环境中运行时,BOM和DOM对象提供了很多相关外部接口(这些接口不是V8引擎提供的),供JS运行时调用,以及JS的事件循环(Event Loop)和事件队列(Callback Queue),把这些称为RunTime。在Node.js中,可以把Node的各种库提供的API称为RunTime

根据Node.js官方介绍,每次事件循环都包含了6个阶段,对应到Libuv源码中的实现,如下图所示,图中显示了事件循环的概述以及执行顺序。

3.Call Stack

当JavaScript代码执行的时候,创建执行环境是很重要的,它可能是下面三种情况中的一种:

  • 全局 code(Global code)——代码第一次执行的默认环境
  • 函数 code(Function code)——执行流进入函数体
  • Eval code(Eval code)——代码在eval函数内部执行

JavaScript代码首次被载入时,会创建一个全局上下文,当调用一个函数时,会创建一个函数执行上下文。

图片 2

stack2.png

在计算机系统中栈是一种遵从先进后出(FILO)原则的区域。函数被调用时,创建一个新的执行环境,就会被加入到执行栈顶部,浏览器始终执行当前在栈顶部的执行环境。一旦函数完成了当前的执行环境,它就会被弹出栈的顶部, 把控制权返回给当前执行环境的下个执行环境。

案例:浏览器第一次加载你的script,它默认的进了全局执行环境,然后main执行创建一个新的执行环境,把它添加到已经存在的执行栈的顶部,在里面执行Student构造函数,执行流进入内部函数 将生成执行环境添加到当前栈顶,在Student构造函数里,又调用sayHi方法,再次把sayHi生成执行环境压入到栈顶。当函数执行完一次弹出栈顶。

class Student {
    constructor(age, name) {
        this.name = name;
        this.age = age;
        this.sayName(); // stack 3
    }
    sayName() {
        console.log(`my name is ${this.name}, this year age is ${this.age}`);
    }
}

function main(age, name) {
    new Student(age, name); // stack 2
}

main(23, 'John'); // stack 1

图片 3

stack.gif

程序运行时,首先main()函数的执行上下文入栈,再调用Student构造函数添加到当前栈尾,在Student里再调用sayName()方法,添加到此时栈尾。最终main方法所在的位置叫栈底,sayName方法所在的位置是栈顶,层层调用,直至整个调用栈完成返回结果,最后再由栈顶依次出栈。

timersj阶段:这个阶段执行timer(setTimeout、setInterval)的回调I/O callbacks:执行一些系统调用错误,比如网络通信的错误回调idle,prepare:仅node内部使用poll:获取新的I/O事件, 适当的条件下node将阻塞在这里check:执行 setImmediate() 的回调close callbacks:执行 socket 的 close 事件回调

4.Event Loop & Callback

Event Loop 类似于一个while(true)的循环,每执行一次循环体的过程我们成为Tick。每个Tick的过程就是查看是否有事件待处理,当Call Stack里面的调用栈运行完变成空了,就取出事件及其相关的回调函数。放到调用栈中并执行它。

图片 4

loop2.png

调用栈中遇到DOM操作、ajax请求以及setTimeout等WebAPIs的时候就会交给浏览器内核的其他模块进行处理,webkit内核在Javasctipt执行引擎之外,有一个重要的模块是webcore模块。对于图中WebAPIs提到的三种API,webcore分别提供了DOM Binding、network、timer模块来处理底层实现。等到这些模块处理完这些操作的时候将回调函数放入任务队列中,之后等栈中的task执行完之后再去执行任务队列之中的回调函数。

图片 5

runtime.png

Javascript有一个main thread 主进程和call-stack(一个调用堆栈),在对一个调用堆栈中的task处理的时候,其他的都要等着。当在执行过程中遇到一些类似于setTimeout等异步操作的时候,会交给浏览器的其他模块(以webkit为例,是webcore模块)进行处理,当到达setTimeout指定的延时执行的时间之后,task(回调函数)会放入到任务队列之中。一般不同的异步任务的回调函数会放入不同的任务队列之中。等到调用栈中所有task执行完毕之后,接着去执行任务队列之中的task(回调函数)。

代码案例:
console.log('Hi');
setTimeout(function cb1() {
    console.log('cb1');
}, 5000);

console.log('Bye');

以上代码从上到下 首先执行log('Hi') 它是一个普通方法立即被执行,当遇到定时器的时候,执行引擎将其添加到调用栈,调用栈发现setTimeout是WebAPIs中的API,将其出栈交给浏览器的timer模块进行处理,此时timer模块去处理延迟执行的函数,此时执行log('Bye'),输出'Bye',当timer模块中延时方法规定的时间到了之后就将其放入到任务队列之中,此时调用栈中的task已经全部执行完毕。

图片 6

image

调用栈中的task执行完毕之后,执行引擎会接着看执行任务队列中是否有需要执行的回调函数。

下面是Node.js事件循环源代码:

五、Event Loop处理机制

int uv_run(uv_loop_t* loop, uv_run_mode mode) { int timeout; int r; int ran_pending; r = uv__loop_alive(loop); if (!r) uv__update_time(loop); while (r != 0  loop-stop_flag == 0) { uv__update_time(loop); // timers阶段 uv__run_timers(loop); // I/O callbacks阶段 ran_pending = uv__run_pending(loop); // idle阶段 uv__run_idle(loop); // prepare阶段 uv__run_prepare(loop); timeout = 0; if ((mode == UV_RUN_ONCE  !ran_pending) || mode == UV_RUN_DEFAULT) timeout = uv_backend_timeout(loop); // poll阶段 uv__io_poll(loop, timeout); // check阶段 uv__run_check(loop); // close callbacks阶段 uv__run_closing_handles(loop); if (mode == UV_RUN_ONCE) { uv__update_time(loop); uv__run_timers(loop); } r = uv__loop_alive(loop); if (mode == UV_RUN_ONCE || mode == UV_RUN_NOWAIT) break; } if (loop-stop_flag != 0) loop-stop_flag = 0; return r;}

1.什么是Event Loop?

Event Loop(事件循环)是实现异步的一种机制,允许 Node.js 执行非阻塞 I/O 操作 .

大多数现代的系统内核都是多线程的, 他们在后台可以处理多个同时执行的操作. 当其中一个操作完成时, 系统内核会通知Node.js, 然后与之相关的回调函数会被加入到 poll队列 并且最终被执行.

图片 7

loop-phase.png

注意: 在Windows和Unix/Linux实现之间存在一点小小的差异, 但对本示例来说这并不重要. 最重要的部分都已列在这里了. 实际上有7或8个阶段, 但我们关心的和Node.js实际会用到的阶段都已经列在了上面.

每个阶段都有一个先进先出(FIFO)的队列,里面存放着要执行的回调函数,然而每个阶段都有其特殊之处,当事件循环进入了某个阶段后,它可以执行该阶段特有的任意操作,然后进行该阶段的任务队列中的回调函数,一直到队列为空或已执行回调的数量达到了允许的最大值,当队列为空或已执行回调的数量达到了允许的最大值时,事件循环会进入下一个阶段,阶段之间会互相转换,循环顺序并不是完全固定的 ,因为很多阶段是由外部的事件触发的。

假设事件循环进入到某一个阶段,及时在这期间其他队列中的事件已经准备就绪,也会先将当前阶段对应队列中所有的回调方法执行完毕之后才会继续向下执行,结合代码也是能够很好的理解的。不难可以得出在事件循环系统中回调的执行顺序是有迹可循的,同样也会造成事件阻塞。

2.阶段概览

  • timers(定时器):此阶段执行由setTimeout()和setInterval() 调度的回调函数

  • I/O callbacks(I/O回调): 此阶段会执行几乎所有的回调函数,处理close callbacks 和那些 由times与setImmediate()调度的回调

  • idle(空闲),prepare(预备): 此阶段只在内部调用

  • poll(轮询): 检索新的I/O事件,在恰当的时候会阻塞在这个阶段

  • check(检查): setImmediate() 设置的回调会在此阶段被调用

  • close callbacks(关闭事件的回调): 诸如 socket.on('close', ...) 此类的回调在此阶段被调用

在事件循环的每次运行之间,Node.js会检查它是否在等待异步I/O或定时器, 如果没有的话就会自动关闭.

一次事件循环就是处理以上几个phase的过程,此外还有两个比较特殊的队列Next Ticks Queue和Other Microtasks Queue,那另外两个特殊的队列是在什么时候运行的呢?

  答案: 就是在每个 phase运行完后马上就检查这两个队列有无数据,有的话就马上执行这两个队列中的数据直至队列为空。当这两个队列都为空时,event loop 就会接着执行下一个phase。
这两个队列相比,Next Ticks Queue的权限要比Other Microtasks Queue的权限要高,因此Next Ticks Queue会先执行。

两个比较特殊的队列:

  • Next Ticks Queue: 保存process.nextTick中的回调函数
  • Other Microtasks Queue: 保存promise等microtask中的回调函数。
var fs = require("fs");fs.readFile('input.txt', function (err, data) { if (err){ console.log(err.stack); return; } console.log(data.toString());});fs.readFile('test.txt', function (err, data) { if (err){ console.log(err.stack); return; } console.log(data.toString());});console.log("程序执行完毕");

3.阶段详情

由于这些操作中的任意一个都可以调度更多的操作, 在 poll(轮询) 阶段处理的新事件被系统内核加入队列, 当轮询事件正在被处理时新的轮询事件也可以被加入队列. 因此, 长时间运行的回调函数可以让 poll 阶段运行的时间比 timer(计时器) 的阈值长得多。 看下面timer 和 poll 部分了解更多细节

对于整个事件循环有个一个大概的认知之后,接下来针对每个阶段进行详细的说明。

timers

给一个定时器(setTimeout/setInterval)指定时间阈值时,给定的回调函数有时并不是在精确的时间阈值点执行,定时器的阈值只是说 至少在这个时间阈值点执行,然而操作系统调度或其他回调的执行可能会延迟定时器回调的执行。

注意:从技术来讲, poll阶段会控制定时器何时被执行

const fs = require('fs');

// 设定一个100ms执行的定时器
const startTime = Date.now();
setTimeout(() => {
    console.log('timeout延迟执行时间', Date.now() - startTime);
    console.log('timer');
}, 100);

// 异步读取文件 假设95ms完成读取任务
fs.readFile('./1.txt', (err, data) => { // 回调函数中又耗费100毫秒
    const startTime = Date.now();
    while (Date.now() - startTime < 200) {
        // console.log(Date.now() - startTime);
    }
});

开始事件循环定时器被加入到timer中延迟执行,当事件循环进入poll阶段,它有一个队列执行I/O操作(fs.readFile())还未完成,poll阶段将会阻塞,大约95ms 完成了I/O操作(文件读取),将要耗时10ms才能完成的回调加入poll队列并执行,当回调执行完成,poll Queue为空,此时poll会去timer阶段查看最近有没有到期的定时器,发现存在一个已经超时将近195ms的定时器,并执行定时器回调。在这个例子中如果不假设读取时间,定时器执行的时间间隔大约为200ms。

注意: 为了防止 poll 阶段阻塞事件循环, libuv(一个实现了Node.js事件循环和Node.js平台所有异步行为的C语言库), 有一个严格的最大限制(这个值取决于操作系统), 在超过此限制后就会停止轮询.

timers

I/O callbacks

此阶段执行一些系统操作处理 I/O 异常错误;,如TCP的errors回调函数。

该阶段主要用来处理定时器相关的回调方法,当一个定时器超市后一个事件就会加入到该阶段的队列中,事件循环会跳转至这个阶段执行对应的回调方法。

poll

poll 阶段主要有两个功能:

1.执行时间阈值已过去的定时器回调

2.处理poll队列中的事件

定时器的回调会在触发后尽可能早的被调用,为什么要说尽可能早的呢?因为实际的触发事件可能要比预先设置的时间要长。Node.js并不能保证timer在预设时间到了就会立即执行,因为Node.js对timer的过期检查不一定靠谱,它会受机器上其它运行程序影响,或者那个时间点主线程不空闲。

当事件循环进入poll阶段并且 当前没有定时器时,以下两种情况其中一种会发生:
  • 如果poll队列不是空的,事件循环会遍历队列并同步执行里面的回调函数,直到队列为空或者到达操作系统的限制(操作系统规定的连续调用回调函数的数量的最大值)

  • 如果poll队列是空的,则以下两种情况其中一种将发生:

    • 如果存在被 setImmediate() 调度的回调,事件循环会结束poll阶段并进入check阶段执行那些被 setImmediate() 调度了的回调。

    • 如果没有任何被 setImmediate() 调度的回调,事件循环会等待回调函数被加入队列,一旦回调函数加入了队列,就立即执行它们。

一旦poll队列变为空,事件循环就检查是否已经存在超时的定时器,如果存在,事件循环将绕回到timers阶段执行这些定时器回调。

I/O callbacks

check

此阶段如果poll阶段变为空转(idle)状态,如果存在被 setImmediate() 调度的回调,事件循环不会在poll阶段阻塞等待相应的I/O事件,而直接去check阶段执行 setImmediate() 函数。

在这个阶段中除了timers、setImmediate,以及close操作之外的大多数的回调方法都位于这个阶段执行。例一个TCP socket执行出现了一些错误,那么这个回调函数会在I/O callbacks阶段来执行。名字会让人误解为执行I/O回调处理程序,然而一些常见的回调则会再poll阶段进行处理。

close callbacks

如果一个socket或句柄被突然关闭(例如 socket.destroy()), 'close'事件会在此阶段被触发. 否则 'close'事件会通过 process.nextTick() 被触发.

I/O callbacks阶段主要经过如下过程:

setImmediate() vs setTimeout()

  • setImmediate() 被设计为: 一旦当前的poll阶段完成就执行回调
  • setTimeout() 调度一个回调在时间阀值之后被执行

这两种定时器的执行顺序可能会变化, 这取决于他们是在哪个上下文中被调用的. 如果两种定时器都是从主模块内被调用的, 那么回调执行的时机就受进程性能的约束(进程也会受到系统中正在运行的其他应用程序的影响).

setTimeout(function timeout() {
  console.log('timeout');
}, 0);

setImmediate(function immediate() {
  console.log('immediate');
});

但如果把setImmediate和setTimeout放到了I/O周期中,此时他们的执行顺序永远都是immediate在前,timeout在后

const fs = require('fs');
fs.readFile(__filename, () => {
  setTimeout(() => {
    console.log('timeout');
  }, 0);
  setImmediate(() => {
    console.log('immediate');
  });
});

相比于 setTimeout(), 使用 setImmediate() 的主要优点在于: 只要时在I/O周期内, 不管已经存在多少个定时器, setImmediate()设置的回调总是在定时器回调之前执行

检查是否有pending的I/O回调。如果有,执行回调。如果没有,退出该阶段。检查是否有process.nextTick任务,如果有,全部执行。检查是否有microtask,如果有,全部执行。退出该阶段。poll

process.nextTick()

在上面我们提到了Next Ticks Queue特殊的队列,在这个队列里主要存放process.nextTick这个异步函数。从技术上讲该阶段并不属于事件循环的一部分,不管当前事件循环处于哪个阶段,只要当前阶段操作完毕后进入下个阶段前瞬间执行process.nextTick()

这样一来任何时候在给定阶段调用process.nextTick()时,所有传入process.nextTick()的回调都会在事件循环继续之前被执行。由于允许开发者通过递归调用 process.nextTick() 来阻塞I/O操作, 这也使事件循环无法到达 poll 阶段.

利用process.nextTick函数,我们可以对内部函数作异步处理可能出现的异常,porcess.nextTick(callback, ...args) 允许接收多个参数,callback后面的参数会作为callback的实参传递进来,这样就无需嵌套函数了。

function apiCall(arg, callback) {
    if (typeof arg !== 'string')
        return process.nextTick(callback,
            new TypeError('argument should be string'));
    callback.call(this, arg);
};
apiCall(1, (err) => {
    console.log(err);
});

apiCall('node', (err) => {
    console.log(err);
});

对于Poll阶段其主要的功能主要有两点:

setTimeout() setImmediate() process.nextTick()

  • setTimeout() 在某个时间值过后尽快执行回调函数;
  • process.nextTick() 在当前调用栈结束后就立即处理,这时也必然是“事件循环继续进行之前”
  • setImmediate() 函数是在poll阶段完成后进去check阶段时执行

优先级顺序从高到低: process.nextTick() > setImmediate() > setTimeout()

注:这里只是多数情况下,即轮询阶段(I/O 回调中)。比如之前比较 setImmediate() 和 setTimeout() 的时候就区分了所处阶段/上下文。

处理 poll 队列的事件当有已超时的 timer,执行它的回调函数

Macrotask Queue和Microtask Queue

macrotask 和 microtask 这两个概念, 表示异步任务的两种分类。在挂起任务时,JS 引擎会将所有任务按照类别分到这两个队列中,首先在 macrotask 的队列(这个队列也被叫做 task queue)中取出第一个任务,执行完毕后取出 microtask 队列中的所有任务顺序执行;之后再取 macrotask 任务,周而复始,直至两个队列的任务都取完。

macrotask(宏任务、大任务):

  • script(整体代码)
  • setTimeout
  • setInterval
  • setImmediate
  • I/O
  • UI rendering

microtask(微任务、小任务):

  • promise
  • Object.observe
  • process.nextTick
  • MutationObserver

每个事件循环只处理一个macrotask(大任务) ,但会处理完所有microtask(小任务)。

当事件循环到达poll阶段时,如果这时没有要处理的定时器的回调方法,则会进行如下判断:

参考资料

如果poll队列不为空,则事件循环会按照顺序便利执行队列中的回调方法,这个过程是同步的。

如果poll队列为空则会再次进行判断

若有预设的setImmediate(),事件循环将结束poll阶段进入check阶段,并执行check阶段的任务队列若没有预设的setImmediate(),那么事件循环可能会进入等待状态,并等待新事件的产生,这也是该阶段为什么被命名为poll的原因。出了这些意外,该阶段还会不断的检查是否有相关的定时器超市,如果有就会跳转到timers阶段,然后执行对应的回调方法check

该阶段执行setImmediate()的回调函数。关于setImmediate是一个比较特殊的定时器方法,setImmediate的回调则会加入到check队列中,从事件循环的阶段图可以知道,check阶段的执行顺序是在poll之后的。

一般情况下,事件循环到达poll阶段后,就会检查当前代码是否调用了setImmediate方法,这个在叙述poll阶段的时候已经有提及了,如果一个回调函数是被setImmediate方法调用的,事件循环则会跳出poll阶段从而进入到check阶段。(这一段有点重复...)

close

close阶段是用来管理关闭事件,用于清理应用程序的状态。如程序中的socket关闭等都会加入到close队列中,当本轮事件结束后则会进入下一轮循环。

小结

本文由10bet发布于Web前端,转载请注明出处:Node.js事件循环

关键词:

上一篇:没有了

下一篇:8种网页最常用的动效制作手法分享

最火资讯