《NodeJS开发教程-9事件循环与Timer》

简介

本节我们来讲nodejs中的事件循环机制，之所以和Timer一块讲，是因为Timer的实现依赖事件循环机制，并且可以很好的帮助我们理解nodejs的事件循环原理。

NodeJS事件循环

我们都知道JavaScript是单线程运行的，当然可以通过H5的Worker规范实现多线程运行，但是worker线程是不可以操作dom，调用渲染的，所以我们运行大部分逻辑和操作dom还是在主线程中完成的。JavaScript单线程的高效运行还是要归功于它的事件机制。对比Java在处理普通IO的时候，当前线程是阻塞的，当然Java后面的JDK版本中提出了NIO处理机制，也是为了弥补普通IO处理方式的不足，即：普通IO在处理读写时是比较慢的，当前线程处于等待状态，无疑是对CPU资源的浪费！

JavaScript处理IO是这样的：主线程完全可以不管IO设备，挂起处于等待中的任务，先运行排在后面的任务。等到IO设备返回了结果，再回过头，把挂起的任务继续执行下去。

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

（1）所有同步任务都在主线程上执行，形成一个执行栈（execution context stack）。

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

（3）一旦"执行栈"中的所有同步任务执行完毕，系统就会读取"任务队列"，看看里面有哪些事件。那些对应的异步任务，于是结束等待状态，进入执行栈，开始执行。

（4）主线程不断重复上面的第三步。

归纳总结一下：就是JavaScript有一个主线程和一个异步任务队列线程

下面我们通过具体的例子来印证一下上述的机制：

setTimeout(function()
{
    console.log("setTimeout执行");
});
setImmediate(function () {
    console.log("setImmediate执行");
});
process.nextTick(function()
{
    console.log("process.nextTick执行");
});
Promise.resolve().then(function()
{
    console.log("Promise执行");
});
console.log("同步执行");

process.nextTick(function()
{
    console.log("process.nextTick执行2");
});

上面代码运行后 输出结果，你可以猜想一下输出顺序：

//输出:
同步执行
process.nextTick执行
process.nextTick执行2
Promise执行
setTimeout执行
setImmediate执行

---

当前执行栈

• process.nextTick()
  NodeJS新增的api，表示：在当前"执行栈"的尾部----下一次Event Loop（主线程读取"任务队列"）之前，触发回调函数
• Promise()
  在当前执行栈的尾部执行

---

从任务队列取出来执行

• setTimeout()
  延时时间到，并添加到当前"任务队列"的尾部，在下一次Event Loop时执行时从“任务队列”取出来执行。setInterval()和setTimeout()原理一样。
• setImmediate()
  在当前"任务队列"的尾部添加事件，也就是说，它指定的任务总是在下一次Event Loop时执行

所以我们再去看它的输出结果就比较容易理解了。

---

Promise使用

• 1.Promise的基本结构

var promise = new Promise(function (resolve, rejected) {
    //初始化promise
    resolve("任务开始ok");
});
promise.then(function (p) {
    //执行任务1
}).then(function (m1) {
    //执行任务2
}).then(function (m2) {
     //执行任务3
}).catch(function (e) {
     //如果执行任务中发生异常则捕获
}).finally(function()
{
    console.log("finally执行");
});

通过Promise我们可以实现多个任务的链式调用，这在日常开发中很有用，我们经常会有这种需求，完成一个任务才能接着执行另一个任务，任务彼此是有相互顺序依赖关系的。【注意：finally()方法是ES2018中新增的方法】

来看下使用例子:

var promise = new Promise(function (resolve, rejected) {
    //处理异步逻辑
    console.log("初始化promise");//同步执行
    resolve("任务开始ok");
    // rejected("任务开始异常");
});
promise.then(function (p) {
    console.log("任务开始返回值:" + p);
    return "task1-over";
}).then(function (m1) {
    console.log("任务1返回值:" + m1);

    // throw new Error("任务2抛出异常");
    return "task2-over";
}).then(function (m2) {
    console.log("任务2返回值:" + m2);
    //任务3中延时返回失败
    // setTimeout(function() {
    //      Promise.reject(new Error('promise-reject-event'));
    // }, 10);
}).catch(function (e) {
    console.warn("失败异常捕获:" + e);
});

我们通过resolve()传递当前任务执行的状态，rejected()停止执行后续任务。

• resolve() 任务成功解决并传递给下一个任务
• rejected() 任务解决失败停止传递给下一个任务并抛出异常被catch捕获到

每个任务完成后可以通过return 返回一些信息给下一个任务，当任务中抛出异常，我们可以通过catch去捕获。但是如果我把以上代码"任务3中延时返回失败"注释打开再执行，你会发现catch并未不能正确捕获到该异常，是因为NodeJS事件循环机制,当setTimeout()回调被执行时，该Promise已经执行完了，所以Promise的catch并不会捕获到该异常。如果想捕获到该异常，可以通过process对象监听 "unhandledRejection"事件。

process.on('unhandledRejection', function(err, p) {
    console.error("捕获到unhandledRejection异常:"+err.stack)
});

• 2.Promise.all()以及Promise.race()使用

Promise.all() 可以同时执行多个Promise,直到最后一个Promise执行完后才执行all的回调函数。
Promise.race() 可以同时执行多个Promise,和all正相反，多个中的一个先执行完了，就执行race的回调函数。

看例子:

//Promise.all()等待数组里所有的移除回调完毕后触发.then()
function timeoutTrigger(duration,param)
{
    return new Promise(function(resolve,reject)
    {
         setTimeout(resolve,duration,param);
    });
}

var p1=timeoutTrigger(2000,"参数1");
var p2=timeoutTrigger(5000,"参数2");
var p3=timeoutTrigger(7000,"参数3");

p1.then(function()
{
    console.log("promise1触发,时间:"+new Date().toUTCString());
});
p2.then(function()
{
    console.log("promise2触发,时间:"+new Date().toUTCString());
});
p3.then(function()
{
    console.log("promise3触发,时间:"+new Date().toUTCString());
});

Promise.all([p1,p2,p3]).then(function(m)
{
    console.log("promiseAll触发,时间:%s | %s",new Date().toUTCString(),m);
});

//Promise.race()---和Promise.all()正好相反，谁先执行完 执行all的then()
// Promise.race([p1,p2,p3]).then(function(m)
// {
//     console.log("promiseAll触发,时间:%s | %s",new Date().toUTCString(),m);
// });

Promise.all() 执行输出:

promise1触发,时间:Mon, 21 May 2018 08:12:37 GMT
promise2触发,时间:Mon, 21 May 2018 08:12:40 GMT
promise3触发,时间:Mon, 21 May 2018 08:12:42 GMT
promiseAll触发,时间:Mon, 21 May 2018 08:12:42 GMT | 参数1,参数2,参数3

Promise.race() 执行输出:

promise1触发,时间:Mon, 21 May 2018 08:14:04 GMT
promiseAll触发,时间:Mon, 21 May 2018 08:14:04 GMT | 参数1
promise2触发,时间:Mon, 21 May 2018 08:14:07 GMT
promise3触发,时间:Mon, 21 May 2018 08:14:09 GMT

这节我们讲解了，关于NodeJS事件循环机制、延时处理timer以及Promise异步处理的使用，是NodeJS中比较重要的部分，希望大家熟练掌握。