HTML5 引進的 Web Worker,讓網頁第一次有了在安全前提下把運算丟到背景執行的能力。但嚴格說來,它離「真正的多執行緒」還有一段距離:Worker 與主線程之間沒有共享記憶體,雙方只能靠訊息傳遞同步狀態。也正因如此,它規避了絕大多數的資料競爭問題,代價則是靈活性大幅受限。
Web Worker 天生自帶一個沙箱:你在裡面跑一支獨立的 js 檔,進出都必須透過 postMessage 與 onmessage。訊息內容必須是可序列化的物件。
var worker = new Worker("my.js");
var bundle = {message:'Hello world', id:1};
worker.postMessage(bundle); //postMessage 可以傳一個可序列化的物件過去
worker.onmessage = function(evt){
console.log(evt.data); //worker 傳回來的物件
console.log(bundle); //{message:'Hello world', id:1}
}
//in my.js
onmessage = function(evt){
var data = evt.data;
data.id++;
postMessage(data); //{message:'Hello world', id:2}
}
執行結果很能說明問題:Worker 內部拿到的 data,其 id 確實加了一,但訊息回傳後,主線程 bundle 的 id 完全沒有變動。也就是說,跨線程傳遞的物件其實是被複製了一份,兩邊各自持有自己的副本。資料不共享,讀寫衝突自然不存在,安全性由此而來;而保證安全的代價,就是線程無法直接操作主線程的物件。
這種受限的多線程機制寫起來頗不順手。理想中的 API 應該讓程式碼在語義上就能表達「同時操作多個線程」,例如:
var worker = new ThreadWorker(bundle /*shared obj*/);
worker.run(function(bundle){
//do sth in worker thread...
this.runOnUiThread(function(bundle /*shared obj*/){
//do sth in main ui thread...
});
//...
});
也就是說:啟動 Worker 之後,任意一段程式碼都能被丟進 Worker 執行;而當需要碰觸 UI 線程(例如讀寫 DOM)時,只要呼叫 this.runOnUiThread 就能切回主線程。
function WorkerThread(sharedObj){
this._worker = new Worker("thread.js");
this._completes = {};
this._task_id = 0;
this.sharedObj = sharedObj;
var self = this;
this._worker.onmessage = function(evt){
var ret = evt.data;
if(ret.__UI_TASK__){
//run on ui task
var fn = (new Function("return "+ret.__UI_TASK__))();
fn(ret.sharedObj);
}else{
self.sharedObj = ret.sharedObj;
self._completes[ret.taskId](ret);
}
}
}
WorkerThread.prototype.run = function(task, complete){
var _task = {__THREAD_TASK__:task.toString(), sharedObj: this.sharedObj, taskId: this._task_id};
this._completes[this._task_id++] = complete;
this._worker.postMessage(_task);
}
這段程式碼定義了一個 ThreadWorker 物件:它建立一支執行 thread.js 的 Web Worker,保存共享物件 sharedObj,並負責處理 thread.js 回傳的訊息。若訊息標記為 UI_TASK,就把它還原成函式後在主線程執行;否則視為任務完成,觸發 run 傳入的 complete 回呼。
onmessage = function(evt){
var data = evt.data;
if(data && data.__THREAD_TASK__){
var task = data.__THREAD_TASK__;
try{
var fn = (new Function("return "+task))();
var ctx = {
threadSignal: true,
sleep: function(interval){
ctx.threadSignal = false;
setTimeout(_run, interval);
},
runOnUiThread: function(task){
postMessage({__UI_TASK__:task.toString(), sharedObj:data.sharedObj});
}
function _run(){
ctx.threadSignal = true;
var ret = fn.call(ctx, data.sharedObj);
postMessage({error:null, returnValue:ret, __THREAD_TASK__:task, sharedObj:data.sharedObj, taskId: data.taskId});
}
_run(0);
}catch(ex){
postMessage({error:ex.toString() , returnValue:null, sharedObj: data.sharedObj});
}
}
}
關鍵在於 THREAD_TASK:那是 UI 線程派發給 Worker 的「任務」。由於函式無法序列化,傳輸時一律轉成字串,Worker 端再用 new Function 把它還原成可呼叫的函式(呼叫時把 sharedObj 當參數帶入),執行完畢再把結果連同 sharedObj 一起 postMessage 回主線程。值得留意的是:因為兩個線程實際上並不共享物件,這裡是靠「回傳後重新賦值」的方式人為同步兩邊狀態——這樣做到底算不算線程安全,值得讀者自己想一想。
var t1 = new WorkerThread({i: 100} /*shared obj*/);
setInterval(function(){
t1.run(function(sharedObj){
return sharedObj.i++;
},
function(r){
console.log("t1>" + r.returnValue + ":" + r.error);
}
);
}, 500);
var t2 = new WorkerThread({i: 50});
t2.run(function(sharedObj){
while(this.threadSignal){
sharedObj.i++;
this.runOnUiThread(function(sharedObj){
W("body ul").appendChild("<li>"+sharedObj.i+"</li>");
});
this.sleep(500);
}
return sharedObj.i;
}, function(r){
console.log("t2>" + r.returnValue + ":" + r.error);
});
不論是結構、語義還是可讀性,這樣的寫法都遠比直接操作 postMessage 來得清爽,後續擴充與維護的成本也更低。
關於 Web Worker 的用法探討就寫到這裡。有興趣的讀者可以參考這個專案:
https://github.com/akira-cn/WorkerThread.js (由於 Worker 需要透過 HTTP 環境測試,專案裡附了一支極簡的 httpd.js,用 node 直接跑起來即可。)