DIV CSS 佈局教程網

JavaScript 非同步程式入門:從 asyncWhile 到自製執行鏈,解決瀏覽器「假死」問題
編輯:關於JavaScript     

事情是這樣開始的:我要在瀏覽器端寫一段腳本,把將近兩百筆使用者資料批次送進公司系統。系統的資料表不是行列式結構,沒辦法直接組 SQL 批次寫入,手工輸入大概要耗掉一整天。於是選擇用 Greasemonkey 寫使用者腳本、以 Firefox 為執行環境,讓程式去模擬點擊與輸入。

需求拆解

腳本要做的事,邏輯上就是一個迴圈:

  1. 在腳本裡預先存好要插入的資料
  2. 模擬點擊,打開頁面的輸入視窗
  3. 把資料填進去,按下「提交」
  4. 等視窗關閉,處理下一筆,直到全部完成

菜鳥寫法為什麼會當掉

最直覺的實作看起來是這樣:

for (var i = 0; i < dataArray.length; ++i) {
  clickButtonForInputWindow();
  waitInputWindow();
  enterInputData(dataArray[i]);
  clickSubmitButton();
  waitInputWindowClose();
}

貼進瀏覽器主控台跑跑看,結果是整頁白屏,幾分鐘後跳出「沒有回應」並被強制終止。原因很單純:JavaScript 執行期間,瀏覽器主執行緒被完全佔用,CPU 忙著跑你的迴圈,根本沒有時間去處理畫面繪製與使用者輸入。而且那些 waitXxx() 也根本沒有真的在等——它們只是空轉。

瀏覽器唯一的非同步工具:setTimeout

把迴圈改成計時器派工:

for (var i = 0; i < dataArray.length; ++i) {
  setTimeout(clickButtonForInputWindow);
  // …
  setTimeout(waitInputWindowClose);
}

setTimeout 與 setInterval 是瀏覽器唯一提供的非同步排程機制。它的本質是「把函式丟進佇列,交還控制權給瀏覽器,之後再回來執行」。控制權一交還,畫面就能刷新、使用者操作也會被處理,白屏問題自然消失。

老牌方案是 jQuery 作者的 $await(Wind.js)那類函式庫,寫起來優雅。但對「單一檔案的 userscript」來說,多下一個外部 js 還不如直接複製幾十行相容程式碼來得爽快。所以決定自己寫一個免編譯、好 Copy & Paste 的迷你非同步庫。

先想清楚:非同步的困難在哪

同步程式只有三種結構:順序、判斷、迴圈。轉成非同步之後,難點也正好三個:

  • 非同步的判斷:通常是「持續檢測某條件是否成立,成立後執行某動作」。
  • 非同步的順序:每一步之後都要交還控制權,在下一個時間片才繼續。難點是如何維持順序性——尤其當兩個順序動作中間夾著一個非同步迴圈時。
  • 非同步的迴圈:每次迭代後交還控制權,反覆直到結束。

asyncWhile:非同步迴圈

function asyncWhile(fn, interval) {
  if (fn == null || (typeof(fn) != "string" && typeof(fn) != "function"))
    return;

  var wrapper = function () {
    // fn 回傳非 false 就繼續排下一輪
    if ((typeof(fn) == "function" ? fn() : eval(fn)) !== false) {
      setTimeout(wrapper, interval == null ? 1 : interval);
    }
  };
  wrapper();
}

核心只有一句:回傳值不是 false 就繼續排下一個 setTimeout。用「回傳值」當控制訊號,是這個設計最聰明的地方。

於是「等待並執行」也能用它表達——這其實就是一個非同步迴圈:

asyncWhile(function () {
  if (xxxCondition == false) {
    return true;      // 繼續循環
  } else {
    doSomeThing();
    return false;     // 不需要再循環了
  }
});

單純「等一下再執行一次」的情境,一個 setTimeout 就夠了,不必動用 asyncWhile。

asyncSeq:真正的難題——非同步中的順序

我的實際需求是三步,但第二步是一個跑一百多次的非同步迴圈。也就是說,表面三步,實際上是一百零三次必須嚴格順序執行的非同步操作。

解法是引入執行鏈(Execution Chain)的概念:

  • 同一條執行鏈上的所有函式嚴格順序執行。
  • 不同執行鏈之間互不干涉,可以交錯進行。
  • 不提供 mutex 等互斥機制;需要同步的話,自行在程式碼中檢查。

實作方式是替每條鏈維護一個「執行令牌」與當前索引,只有令牌序號與函式序號相符時才允許執行:

function asyncSeq(funcArray, chainName, abortWhenError) {
  if (typeof(funcArray) == "function")
    return asyncSeq([funcArray], chainName, abortWhenError);

  if (funcArray == null || funcArray.length == 0) return;

  if (chainName == null) chainName = "__default_seq_chain__";

  var tInfos = asyncSeq.chainInfos = asyncSeq.chainInfos || {};
  var tInfo = tInfos[chainName] =
    tInfos[chainName] || { count: 0, currentIndex: -1, abort: false };

  for (var i = 0; i < funcArray.length; ++i) {
    asyncWhile(function (item, tIndex) {
      return function () {
        if (tInfo.abort) return false;

        if (tInfo.currentIndex < tIndex) {
          return true;                       // 還沒輪到,再等一個 tick
        } else if (tInfo.currentIndex == tIndex) {
          try {
            item();
          } catch (e) {
            if (abortWhenError) tInfo.abort = true;
          } finally {
            tInfo.currentIndex++;
          }
        } else {
          if (abortWhenError) tInfo.abort = true;
        }
        return false;
      };
    }(funcArray[i], tInfo.count++));
  }

  // 延遲啟動,方便除錯
  setTimeout(function () {
    if (tInfo.count > 0 && tInfo.currentIndex == -1) tInfo.currentIndex = 0;
  }, 20);
}

值得欣賞的兩個設計:

  • 用 IIFE 鎖定序號:(function(item, tIndex){ return function(){…} }(funcArray[i], tInfo.count++))。不這樣做,迴圈變數會被所有閉包共用,全部拿到最後一個值。
  • 「提前等待」的設計:當 currentIndex 落後於自己的序號時回傳 true 繼續排隊,等前面跑完自然輪到自己。這樣就不必做複雜的 callback 串接。

使用範例

function testAsync() {
  asyncSeq([
    function () { println("aSyncSeq -0 "); },
    function () { println("aSyncSeq -1 "); },
    function () { println("aSyncSeq -2 "); }
    // … 可任意擴充
  ]);

  // 不同 chainName,與上面那條同時進行、互不干擾
  asyncSeq([
    function () { println("aSyncSeq test-chain -a0 "); },
    function () { println("aSyncSeq test-chain -a1 "); }
  ], "test-chain");
}

var textArea = null;
function println(text) {
  if (textArea == null) {
    textArea = document.getElementById("text");
    textArea.value = "";
  }
  textArea.value = textArea.value + text + "\r\n";
}

執行結果會看到兩條鏈的輸出交錯出現,但每條鏈內部順序不亂——這就是執行令牌在起作用。

今天回頭看這套設計

這份程式碼的價值不在它有多先進,而在它把非同步的三個難題(迴圈、判斷、順序)用最少的程式碼講清楚了。不過放到現在,你幾乎不會需要自己寫它,因為語言本身已經內建了答案:

// 非同步迴圈 → 就是 await 加 while
while (condition) {
  await doSomething();
}

// 非同步順序 → await 天然保證
await step1();
await step2();
await step3();

// 並行 → Promise.all
await Promise.all(tasks.map(t => t.run()));

async/await 出現之後,「用同步的寫法表達非同步的流程」這件事已經由編譯器(本質上是 generator 加狀態機)代劳,而它在背後做的,正是本文用 currentIndex 令牌手工實作的那套狀態追蹤。

最後補一句實用提醒:批次操作幾百筆資料時,除了避免阻塞主執行緒,也要考慮對伺服器的壓力。每個請求之間加一點隨機延遲、控制併發數量(例如一次只跑 2~3 個),比一路狂送要安全得多,也不容易被後端當成攻擊流量擋掉。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved