js--事件循環機制

前言

　　我們知道JavaScript 是單線程的編程語言，只能同一時間內做一件事，按順序來處理事件，但是在遇到異步事件的時候，js線程並沒有阻塞，還會繼續執行，這又是為什么呢？本文來總結一下js 的事件循環機制。

正文

　　瀏覽器進程，瀏覽器是⼀個多進程多線程的應⽤程序。其中，最主要的進程有：

　　a. 瀏覽器進程主要負責界⾯顯示、⽤戶交互、⼦進程管理等。瀏覽器進程內部會啟動多個線程處理不同的任務。

　　b. ⽹絡進程 負責加載⽹絡資源。⽹絡進程內部會啟動多個線程來處理不同的⽹絡任務。

　　c. 渲染進程 渲染進程啟動后，會開啟⼀個渲染主線程，主線程負責執⾏ HTML、CSS、JS 代碼。 默認情況下，瀏覽器會為每個標簽⻚開啟⼀個新的渲染進程，以保證不同的 標簽⻚之間不相互影響。

　　1、JavaScript是單線程的

　　JavaScript 是一種單線程的編程語言，這是因為它運行在瀏覽器的渲染主線程中，而渲染主線程只有一個，而渲染主線程承擔着諸多工作，渲染頁面、執行 JS 都在其中執行，因此只有一個調用棧，決定了它在同一時間只能做一件事。在代碼執行的時候，通過將不同函數的執行上下文壓入執行棧中來保證代碼的有序執行。在執行同步代碼的時候，如果遇到了異步事件，js 引擎並不會一直等待其返回結果，而是會將這個事件掛起，繼續執行執行棧中的其他任務。因此JS又是一個非阻塞、異步、並發式的編程語言。

 　　2、同步和異步

　　同步和異步的關系就類似於我們在餐廳排隊吃飯的時候，每個人必須挨個的排隊來進行買飯這個操作，而在這個過程中十分無聊，這時候我們可以邊排着隊邊玩下手機，不需多久就排到了我們買飯。這個排隊過程就是JS中的一個同步操作，玩手機就像一個異步操作。同步和異步的差別就在於排隊買飯和玩手機這兩個任務的執行順序的不同。

 　　同步： 指的是在主線程上排隊執行的任務，只有前一個任務執行完畢，才能執行后一個任務。可以理解為在執行完一個函數或方法之后，一直等待系統返回值或消息，這時程序是處於阻塞的，只有接收到返回的值或消息后才往下執行其他的命令。

　　異步： 指的是不進入主線程，某個異步任務可以執行了，該任務才會進入主線程執行。執行完函數或方法后，不必阻塞性地等待返回值或消息，只需要向系統委托一個異步過程，那么當系統接收到返回值或消息時，系統會自動觸發委托的異步過程，從而完成一個完整的流程。

console.log(1);
setTimeout(() => {
  console.log(2);
}, 0);
setTimeout(() => {
  console.log(3);
}, 0);
setTimeout(() => {
  console.log(4);
}, 0);
console.log(5);

　　上面的代碼會打印  1 》 5 》 2 》 3 》4，為什么會產生這樣的結果，我們來看下事件循環。

 　　3、事件循環

　　事件循環過程可以簡單描述為：

　　a、函數入棧，當 Stack 中執行到異步任務的時候，就將他丟給 WebAPIs ,接着執行同步任務,直到 Stack 為空;

　　b、在此期間 WebAPIs 完成這個事件，把回調函數放入 CallbackQueue (任務隊列)中等待;

　　c、當執行棧為空時，Event Loop 把 Callback Queue中的一個任務放入Stack中,回到第1步。

　　事件循環（Event Loop） 是讓 JavaScript 做到既是單線程，又絕對不會阻塞的核心機制，也是 JavaScript 並發模型（Concurrency Model）的基礎，是用來協調各種事件、用戶交互、腳本執行、UI 渲染、網絡請求等的一種機制。在執行和協調各種任務時，Event Loop 會維護自己的消息隊列。

　　消息隊列是一個存儲着待執行任務的隊列，其中的任務嚴格按照時間先后順序執行，排在隊頭的任務將會率先執行，而排在隊尾的任務會最后執行。消息隊列每次僅執行一個任務，在該任務執行完畢之后，再執行下一個任務,一個任務開始后直至結束，不會被其他任務中斷。執行棧則是一個類似於函數調用棧的運行容器，當執行棧為空時，JS 引擎便檢查事件隊列，如果不為空的話，消息隊列便將第一個任務壓入執行棧中運行。

　　任務類型：在JavaScript中，每個任務都有⼀個任務類型，同⼀個類型的任務必須在⼀個隊列，不同類型的任務可以分屬於不同的隊列。在⼀次事件循環中，瀏覽器可以根據實際情況從不同的隊列中取出任務執⾏。異步任務被分為兩種，一種宏任務（MacroTask）也叫Task，一種叫微任務：

　　宏任務的例子很多，包括創建主文檔對象、解析HTML、執行主線（或全局）JavaScript代碼，更改當前URL以及各種事件，如頁面加載、輸入、網絡事件和定時器事件。從瀏覽器的角度來看，宏任務代表一個個離散的、獨立工作單元。運行完任務后，瀏覽器可以繼續其他調度，如重新渲染頁面的UI或執行垃圾回收。

　　而微任務是更小的任務。微任務更新應用程序的狀態，但必須在瀏覽器任務繼續執行其他任務之前執行，瀏覽器任務包括重新渲染頁面的UI。微任務的案例包括promise回調函數、DOM發生變化等。微任務需要盡可能快地、通過異步方式執行，同時不能產生全新的微任務。微任務使得我們能夠在重新渲染UI之前執行指定的行為，避免不必要的UI重繪，UI重繪會使應用程序的狀態不連續。

　　當當前執行棧中的事件執行完畢后，js 引擎首先會判斷微任務對列中是否有任務可以執行，如果有就將微任務隊首的事件壓入棧中執行。當微任務對列中的任務都執行完成后再去判斷宏任務對列中的任務。每次宏任務執行完畢，都會去判斷微任務隊列是否產生新任務，若存在就優先執行微任務，否則按序執行宏任務。

　　事件循環通常至少需要兩個任務隊列：宏任務隊列和微任務隊列。兩種隊列在同一時刻都只執行一個任務。

因此：

　　事件循環是異步的實現方式；單線程是異步產生的原因；　

console.log("script start");

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

Promise.resolve()
  .then(function () {
    console.log("promise1");
  })
  .then(function () {
    console.log("promise2");
  });

console.log("script end");

　　按照上面的內容，分析執行步驟：

　　1、宏任務：執行整體代碼（相當於<script>中的代碼）：

　　　　輸出: script start

　　　　遇到 setTimeout，加入宏任務隊列，當前宏任務隊列(setTimeout)

　　　　遇到 promise，加入微任務，當前微任務隊列(promise1)

　　　　輸出：script end

　　2、微任務：執行微任務隊列（promise1）

　　　　輸出：promise1，then 之后產生一個微任務，加入微任務隊列，當前微任務隊列（promise2）

　　　　執行 then，輸出promise2

　　　　執行渲染操作，更新界面。

　　　　宏任務：執行 setTimeout

　　　　輸出：setTimeout

　　注意：new Promise(..)中的代碼，也是同步代碼，會立即執行。只有then之后的代碼，才是異步執行的代碼，是一個微任務。

console.log("script start");

setTimeout(function () {
  console.log("timeout1");
}, 10);

new Promise((resolve) => {
  console.log("promise1");
  resolve();
  setTimeout(() => console.log("timeout2"), 10);
}).then(function () {
  console.log("then1");
});

console.log("script end");

 　　步驟解析：

 　　當前任務隊列：微任務: [], 宏任務：[<script>]

 　　宏任務：

　　　　輸出: script start

　　　　遇到 timeout1，加入宏任務

　　　　遇到 Promise，輸出promise1，直接 resolve，將 then 加入微任務，遇到 timeout2，加入宏任務。

　　　　輸出script end

　　宏任務第一個執行結束

　　當前任務隊列：微任務[then1]，宏任務[timeou1, timeout2]

　　微任務：

　　　　執行 then1，輸出then1

　　微任務隊列清空

　　當前任務隊列：微任務[]，宏任務[timeou1, timeout2]

　　宏任務：

 　　　　輸出timeout1

　　　　輸出timeout2

　　當前任務隊列：微任務[]，宏任務[timeou2]

　　微任務：

　　　　為空跳過

　　當前任務隊列：微任務[]，宏任務[timeou2]

　　宏任務：

　　　　輸出timeout2

　　注意：async 和 await 其實就是 Generator 和 Promise 的語法糖。async 函數和普通 函數沒有什么不同，他只是表示這個函數里有異步操作的方法，並返回一個 Promise 對象

async function async1() {
  console.log("async1 start");
  await async2();
  console.log("async1 end");
}
// Promise 寫法
async function async1() {
  console.log("async1 start");
  Promise.resolve(async2()).then(() => console.log("async1 end"));
}

　　下面例子：

async function async1() {
  console.log("async1 start");
  await async2();
  console.log("async1 end");
}
async function async2() {
  console.log("async2");
}
async1();
setTimeout(() => {
  console.log("timeout");
}, 0);
new Promise(function (resolve) {
  console.log("promise1");
  resolve();
}).then(function () {
  console.log("promise2");
});
console.log("script end");

 　　步驟解析：

　　當前任務隊列：宏任務：[<script>]，微任務: []

　　宏任務：

 　　　　輸出：async1 start

　　　　遇到 async2，輸出：async2，並將 then（async1 end）加入微任務

　　　　遇到 setTimeout，加入宏任務。

　　　　遇到 Promise，輸出：promise1，直接 resolve，將 then(promise2)加入微任務

　　　　輸出：script end

　　當前任務隊列：微任務[async1 end，promise2]，宏任務[timeout]

　　微任務：

　　　　輸出：async1 end

　　　　async1 end 出隊

　　　　輸出：promise2

　　　　promise2 出隊

　　　　微任務隊列清空

　　當前任務隊列：微任務[]，宏任務[timeout]

　　宏任務：

　　　　輸出：timeout

　　　　timeout 出隊，宏任務清空

 

　　補充：

 　　 1、隨着瀏覽器的復雜度急劇提升，W3C 不再使⽤宏隊列的說法 ， 在⽬前 chrome 的實現中，⾄少包含了下⾯的隊列：

　　　　延時隊列：⽤於存放計時器到達后的回調任務，優先級「中」

　　　　交互隊列：⽤於存放⽤戶操作后產⽣的事件處理任務，優先級「⾼」

　　　　微隊列：⽤戶存放需要最快執⾏的任務，優先級「最⾼」

　　2、JS 中的計時器能做到精確計時嗎？為什么？

　　　　不⾏，因為：

　　　　a. 計算機硬件沒有原⼦鍾，⽆法做到精確計時

　　　　b. 操作系統的計時函數本身就有少量偏差，由於 JS 的計時器最終調⽤的 是操作系統的函數，也就攜帶了這些偏差

　　　　c. 按照 W3C 的標准，瀏覽器實現計時器時，如果嵌套層級超過 5 層， 則會帶有 4 毫秒的最少時間，這樣在計時時間少於 4 毫秒時⼜帶來 了偏差

　　　　d. 受事件循環的影響，計時器的回調函數只能在主線程空閑時運⾏，因此 ⼜帶來了偏差

寫在最后

　　以上就是本文的全部內容，希望給讀者帶來些許的幫助和進步，方便的話點個關注，小白的成長之路會持續更新一些工作中常見的問題和技術點。