一文詳解Node.js中的事件迴圈

   ┌───────────────────────┐
┌─>│        timers         │
│  └──────────┬────────────┘
│  ┌──────────┴────────────┐
│  │     I/O callbacks     │
│  └──────────┬────────────┘
│  ┌──────────┴────────────┐
│  │     idle, prepare     │
│  └──────────┬────────────┘      ┌───────────────┐
│  ┌──────────┴────────────┐      │   incoming:   │
│  │         poll          │<─────┤  connections, │
│  └──────────┬────────────┘      │   data, etc.  │
│  ┌──────────┴────────────┐      └───────────────┘
│  │        check          │
│  └──────────┬────────────┘
│  ┌──────────┴────────────┐
└──┤    close callbacks    │
   └───────────────────────┘

// 事件迴圈本身相當於一個死迴圈，當程式碼開始執行的時候，事件迴圈就已經啟動了
// 然後順序呼叫不同階段的方法
while(true){
// timer階段
    timer()
// I/O callbacks階段
    IO()
// idle階段
    IDLE()
// poll階段
    poll()
// check階段
    check()
// close階段
    close()
}
// 在一次迴圈中，當事件迴圈進入到某一階段，加入進入到check階段，突然timer階段的事件就緒，也會等到當前這次迴圈結束，再去執行對應的timer階段的回撥函數 
// 下面看這裡例子
const fs = require('fs')

// timers階段
const startTime = Date.now();
setTimeout(() => {
    const endTime = Date.now()
    console.log(`timers: ${endTime - startTime}`)
}, 1000)

// poll階段(等待新的事件出現)
const readFileStart =  Date.now();
fs.readFile('./Demo.txt', (err, data) => {
    if (err) throw err
    let endTime = Date.now()
    // 獲取檔案讀取的時間
    console.log(`read time: ${endTime - readFileStart}`)
    // 通過while迴圈將fs回撥強制阻塞5000s
    while(endTime - readFileStart < 5000){
        endTime = Date.now()
    }

})


// check階段
setImmediate(() => {
    console.log('check階段')
})
/*控制檯列印check階段read time: 9timers: 5008通過上述結果進行分析，1.程式碼執行到定時器setTimeOut，目前timers階段對應的事件列表為空，在1000s後才會放入事件2.事件迴圈進入到poll階段，開始不斷的輪詢監聽事件3.fs模組非同步執行，根據檔案大小，可能執行時間長短不同，這裡我使用的小檔案，事件大概在9s左右4.setImmediate執行，poll階段暫時未監測到事件，發現有setImmediate函數，跳轉到check階段執行check階段事件（列印check階段），第一次時間迴圈結束，開始下一輪事件迴圈5.因為時間仍未到定時器截止時間，所以事件迴圈有一次進入到poll階段，進行輪詢6.讀取檔案完畢，fs產生了一個事件進入到poll階段的事件佇列，此時事件佇列準備執行callback，所以會列印（read time: 9），人工阻塞了5s，雖然此時timer定時器事件已經被新增，但是因為這一階段的事件迴圈為完成，所以不會被執行，（如果這裡是死迴圈，那麼定時器程式碼永遠無法執行）7.fs回撥阻塞5s後，當前事件迴圈結束，進入到下一輪事件迴圈，發現timer事件佇列有事件，所以開始執行 列印timers: 5008ps：1.將定時器延遲時間改為5ms的時候，小於檔案讀取時間，那麼就會先監聽到timers階段有事件進入，從而進入到timers階段執行，執行完畢繼續進行事件迴圈check階段timers: 6read time: 50082.將定時器事件設定為0ms，會在進入到poll階段的時候發現timers階段已經有callback，那麼會直接執行，然後執行完畢在下一階段迴圈，執行check階段，poll佇列的回撥函數timers: 2check階段read time: 7 */

const fs = require('fs');
let counts = 0;

// 定義一個 wait 方法
function wait (mstime) {
  let date = Date.now();
  while (Date.now() - date < mstime) {
    // do nothing
  }
}

// 讀取本地檔案 操作IO
function asyncOperation (callback) {
  fs.readFile(__dirname + '/' + __filename, callback);
}

const lastTime = Date.now();

// setTimeout
setTimeout(() => {
  console.log('timers', Date.now() - lastTime + 'ms');
}, 0);

// process.nextTick
process.nextTick(() => {
  // 進入event loop
  // timers階段之前執行
  wait(20);
  asyncOperation(() => {
    console.log('poll');
  });  
});

/** * timers 21ms * poll */

const fs = require('fs');
let counts = 0;

function wait (mstime) {
  let date = Date.now();
  while (Date.now() - date < mstime) {
    // do nothing
  }
}

function nextTick () {
  process.nextTick(() => {
    wait(20);
    console.log('nextTick');
    nextTick();
  });
}

const lastTime = Date.now();

setTimeout(() => {
  console.log('timers', Date.now() - lastTime + 'ms');
}, 0);

nextTick();

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

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

C:\Users\92809\Desktop\node_test>node test.js
timeout
immediate

C:\Users\92809\Desktop\node_test>node test.js
timeout
immediate

C:\Users\92809\Desktop\node_test>node test.js
timeout
immediate

C:\Users\92809\Desktop\node_test>node test.js
immediate
timeout

var fs = require('fs')

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

C:\Users\92809\Desktop\node_test>node test.js
immediate
timeout

C:\Users\92809\Desktop\node_test>node test.js
immediate
timeout

C:\Users\92809\Desktop\node_test>node test.js
immediate
timeout

# ... 省略 n 多次使用 node test.js 命令 ，結果都輸出 immediate timeout

setTimeout(() => {
    setImmediate(() => {
        console.log('setImmediate');
    });
    setTimeout(() => {
        console.log('setTimeout');
    }, 0);
}, 0);

setTimeout(() => {
    console.log('timeout0');
    new Promise((resolve, reject) => { resolve('resolved') }).then(res => console.log(res));
    new Promise((resolve, reject) => {
      setTimeout(()=>{
        resolve('timeout resolved')
      })
    }).then(res => console.log(res));
    process.nextTick(() => {
        console.log('nextTick1');
        process.nextTick(() => {
            console.log('nextTick2');
        });
    });
    process.nextTick(() => {
        console.log('nextTick3');
    });
    console.log('sync');
    setTimeout(() => {
        console.log('timeout2');
    }, 0);
}, 0);

C:\Users\92809\Desktop\node_test>node test.js
timeout0
sync
nextTick1
nextTick3
nextTick2
resolved
timeout2
timeout resolved

setImmediate(function(){
  console.log("setImmediate");
  setImmediate(function(){
    console.log("巢狀setImmediate");
  });
  process.nextTick(function(){
    console.log("nextTick");
  })
});

/*     C:\Users\92809\Desktop\node_test>node test.js    setImmediate    nextTick    巢狀setImmediate*/

async function async1(){
    console.log('async1 start')
    await async2()
    console.log('async1 end')
  }
async function async2(){
    console.log('async2')
}
console.log('script start')
setTimeout(function(){
    console.log('setTimeout0') 
},0)  
setTimeout(function(){
    console.log('setTimeout3') 
},3)  
setImmediate(() => console.log('setImmediate'));
process.nextTick(() => console.log('nextTick'));
async1();
new Promise(function(resolve){
    console.log('promise1')
    resolve();
    console.log('promise2')
}).then(function(){
    console.log('promise3')
})
console.log('script end')

C:\Users\92809\Desktop\node_test>node test.js
script start
async1 start
async2
promise1
promise2
script end
nextTick
promise3
async1 end
setTimeout0
setTimeout3
setImmediate