HTML5之web workers_动力节点Java学院整理

专用 web worker (dedicated web worker) 提供了一个简单的方法使得 web 内容能够在后台运行脚本。一旦 worker 创建后，它可以向由它的创建者指定的事件监听函数传递消息，这样该 worker 生成的所有任务就都会接收到这些消息。worker 线程能够在不干扰 ui 的情况下执行任务。另外，它还能够使用xmlhttprequest(虽然responsexml与channel 两个属性值始终是null)来执行i/o 操作。本文通过提供例子和细节补全了前面的文档。提供给 worker 的函数列出了 worker 所支持的函数。

worker接口会生成真正的操作系统级别的线程，如果你不太小心，那么并发(concurrency)会对你的代码产生有趣的影响。然而，对于 web worker 来说，与其他线程的通信点会被很小心的控制，这意味着你很难引起并发问题。你没有办法去访问非线程安全的组件或者是 dom，此外你还需要通过序列化对象来与线程交互特定的数据。所以你要是不费点劲儿，还真搞不出错误来。生成 worker

创建一个新的 worker 十分简单。你所要做的就是调用worker()构造函数，指定一个要在 worker 线程内运行的脚本的 uri，如果你希望能够收到 worker 的通知，可以将 worker 的onmessage属性设置成一个特定的事件处理函数。

var myworker = new worker("my_task.js");
myworker.onmessage = function (oevent) {
  console.log("called back by the worker!\n");
};

或者，你也可以使用addeventlistener()：

var myworker = new worker("my_task.js");
myworker.addeventlistener("message", function (oevent) {
  console.log("called back by the worker!\n");
}, false);
myworker.postmessage(""); // start the worker.

例子中的第一行创建了一个新的 worker 线程。第三行为 worker 设置了message事件的监听函数。当 worker 调用自己的postmessage() 函数时就会调用这个事件处理函数。最后，第七行启动了 worker 线程。注意： 传入worker构造函数的参数 uri 必须遵循同源策略。目前，不同的浏览器制造商对于哪些 uri 应该遵循同源策略尚有分歧；gecko 10.0 (firefox 10.0 / thunderbird 10.0 / seamonkey 2.7) 及后续版本允许传入 data uri，而 internet explorer 10 则不认为 blob uri 对于 worker 来说是一个有效的脚本。

传递数据

在主页面与 worker 之间传递的数据是通过拷贝，而不是共享来完成的。传递给worker 的对象需要经过序列化，接下来在另一端还需要反序列化。页面与 worker不会共享同一个实例，最终的结果就是在每次通信结束时生成了数据的一个副本。大部分浏览器使用结构化拷贝来实现该特性。

在往下进行之前，出于教学的目的，让我们创建一个名为emulatemessage()的函数，它将模拟在从worker到主页面(反之亦然)的通信过程中，变量的「拷贝而非共享」行为：

function emulatemessage (vval) {
    return eval("(" + json.stringify(vval) + ")");
}
// tests
// test #1
var example1 = new number(3);
alert(typeof example1); // object
alert(typeof emulatemessage(example1)); // number
// test #2
var example2 = true;
alert(typeof example2); // boolean
alert(typeof emulatemessage(example2)); // boolean
// test #3
var example3 = new string("hello world");
alert(typeof example3); // object
alert(typeof emulatemessage(example3)); // string
// test #4
var example4 = {
    "name": "john smith",
    "age": 43
};
alert(typeof example4); // object
alert(typeof emulatemessage(example4)); // object
// test #5
function animal (stype, nage) {
    this.type = stype;
    this.age = nage;
}
var example5 = new animal("cat", 3);
alert(example5.constructor); // animal
alert(emulatemessage(example5).constructor); // object

拷贝而并非共享的那个值称为消息。再来谈谈worker，你可以使用postmessage() 将消息传递给主线程或从主线程传送回来。message事件的data属性就包含了从 worker 传回来的数据。

example.html: (主页面):

var myworker = new worker("my_task.js");
myworker.onmessage = function (oevent) {
  console.log("worker said : " + oevent.data);
};
myworker.postmessage("ali");
my_task.js (worker):
postmessage("i\'m working before postmessage(\'ali\').");
onmessage = function (oevent) {
  postmessage("hi " + oevent.data);
};

注意：通常来说，后台线程 – 包括 worker –无法操作 dom。如果后台线程需要修改 dom，那么它应该将消息发送给它的创建者，让创建者来完成这些操作。

如你所见，worker与主页面之间传输的消息始终是「json 消息」，即使它是一个原始类型的值。所以，你完全可以传输json数据 和/或 任何能够序列化的数据类型：

postmessage({"cmd": "init", "timestamp": date.now()});

传递数据的例子

例子 #1： 创建一个通用的 「异步eval()」

下面这个例子介绍了，如何在 worker 内使用eval()来按顺序执行异步的任何种类的 javascript 代码：

// syntax: asynceval(code[, listener])
var asynceval = (function () {
  var alisteners = [], oparser = new worker("data:text/javascript;charset=us-ascii,onmessage%20%3d%20function%20%28oevent%29%20%7b%0a%09postmessage%28%7b%0a%09%09%22id%22%3a%20oevent.data.id%2c%0a%09%09%22evaluated%22%3a%20eval%28oevent.data.code%29%0a%09%7d%29%3b%0a%7d");
  oparser.onmessage = function (oevent) {
    if (alisteners[oevent.data.id]) { alisteners[oevent.data.id](oevent.data.evaluated); }
    delete alisteners[oevent.data.id];
  };
  return function (scode, flistener) {
    alisteners.push(flistener || null);
    oparser.postmessage({
      "id": alisteners.length - 1,
      "code": scode
    });
  };
})();

示例使用：

// asynchronous alert message...
asynceval("3 + 2", function (smessage) {
    alert("3 + 2 = " + smessage);
});
// asynchronous print message...
asynceval("\"hello world!!!\"", function (shtml) {
    document.body.appendchild(document.createtextnode(shtml));
});
// asynchronous void...
asynceval("(function () {\n\tvar oreq = new xmlhttprequest();\n\toreq.open(\"get\", \"http://www.mozilla.org/\", false);\n\toreq.send(null);\n\treturn oreq.responsetext;\n})()");

例子 #2：传输 json 的高级方式和创建一个交换系统

如果你需要传输非常复杂的数据，还要同时在主页与 worker 内调用多个方法，那么可以考虑创建一个类似下面的系统。

example.html(the main page):

<!doctype html>
<html>
<head>
<meta charset="utf-8"  />
<title>mdn example - queryable worker</title>
<script type="text/javascript">
  /*
    queryableworker instances methods:
     * sendquery(queryable function name, argument to pass 1, argument to pass 2, etc. etc): calls a worker's queryable function
     * postmessage(string or json data): see worker.prototype.postmessage()
     * terminate(): terminates the worker
     * addlistener(name, function): adds a listener
     * removelistener(name): removes a listener
    queryableworker instances properties:
     * defaultlistener: the default listener executed only when the worker calls the postmessage() function directly
  */
  function queryableworker (surl, fdeflistener, fonerror) {
    var oinstance = this, oworker = new worker(surl), olisteners = {};
    this.defaultlistener = fdeflistener || function () {};
    oworker.onmessage = function (oevent) {
      if (oevent.data instanceof object && oevent.data.hasownproperty("vo42t30") && oevent.data.hasownproperty("rnb93qh")) {
        olisteners[oevent.data.vo42t30].apply(oinstance, oevent.data.rnb93qh);
      } else {
        this.defaultlistener.call(oinstance, oevent.data);
      }
    };
    if (fonerror) { oworker.onerror = fonerror; }
    this.sendquery = function (/* queryable function name, argument to pass 1, argument to pass 2, etc. etc */) {
      if (arguments.length < 1) { throw new typeerror("queryableworker.sendquery - not enough arguments"); return; }
      oworker.postmessage({ "bk4e1h0": arguments[0], "ktp3fm1": array.prototype.slice.call(arguments, 1) });
    };
    this.postmessage = function (vmsg) {
      //i just think there is no need to use call() method
      //how about just oworker.postmessage(vmsg);
      //the same situation with terminate
      //well,just a little faster,no search up the prototye chain
      worker.prototype.postmessage.call(oworker, vmsg);
    };
    this.terminate = function () {
      worker.prototype.terminate.call(oworker);
    };
    this.addlistener = function (sname, flistener) {
      olisteners[sname] = flistener;
    };
    this.removelistener = function (sname) {
      delete olisteners[sname];
    };
  };
  // your custom "queryable" worker
  var omytask = new queryableworker("my_task.js" /* , yourdefaultmessagelistenerhere [optional], yourerrorlistenerhere [optional] */);
  // your custom "listeners"
  omytask.addlistener("printsomething", function (nresult) {
    document.getelementbyid("firstlink").parentnode.appendchild(document.createtextnode(" the difference is " + nresult + "!"));
  });
  omytask.addlistener("alertsomething", function (ndeltat, sunit) {
    alert("worker waited for " + ndeltat + " " + sunit + " :-)");
  });
</script>
</head>
<body>
  <ul>
    <li><a id="firstlink" href="javascript:omytask.sendquery('getdifference', 5, 3);">what is the difference between 5 and 3?</a></li>
    <li><a href="javascript:omytask.sendquery('waitsomething');">wait 3 seconds</a></li>
    <li><a href="javascript:omytask.terminate();">terminate() the worker</a></li>
  </ul>
</body>
</html>
my_task.js (the worker):
// your custom private functions
function myprivatefunc1 () {
  // do something
}
function myprivatefunc2 () {
  // do something
}
// etc. etc.
// your custom public functions (i.e. queryable from the main page)
var queryablefunctions = {
  // example #1: get the difference between two numbers:
  getdifference: function (nminuend, nsubtrahend) {
      reply("printsomething", nminuend - nsubtrahend);
  },
  // example #2: wait three seconds
  waitsomething: function () {
      settimeout(function() { reply("alertsomething", 3, "seconds"); }, 3000);
  }
};
// system functions
function defaultquery (vmsg) {
  // your default public function executed only when main page calls the queryableworker.postmessage() method directly
  // do something
}
function reply (/* listener name, argument to pass 1, argument to pass 2, etc. etc */) {
  if (arguments.length < 1) { throw new typeerror("reply - not enough arguments"); return; }
  postmessage({ "vo42t30": arguments[0], "rnb93qh": array.prototype.slice.call(arguments, 1) });
}
onmessage = function (oevent) {
  if (oevent.data instanceof object && oevent.data.hasownproperty("bk4e1h0") && oevent.data.hasownproperty("ktp3fm1")) {
    queryablefunctions[oevent.data.bk4e1h0].apply(self, oevent.data.ktp3fm1);
  } else {
    defaultquery(oevent.data);
  }
};

这是一个非常合适的方法，用于切换 主页-worker - 或是相反的 - 之间的消息。

通过转让所有权(可转让对象)来传递数据

google chrome 17 与 firefox 18 包含另一种性能更高的方法来将特定类型的对象(可转让对象) 传递给一个 worker/从 worker 传回 。可转让对象从一个上下文转移到另一个上下文而不会经过任何拷贝操作。这意味着当传递大数据时会获得极大的性能提升。如果你从 c/c++ 世界来，那么把它想象成按照引用传递。然而与按照引用传递不同的是，一旦对象转让，那么它在原来上下文的那个版本将不复存在。该对象的所有权被转让到新的上下文内。例如，当你将一个arraybuffer对象从主应用转让到worker 中，原始的arraybuffer被清除并且无法使用。它包含的内容会(完整无差的)传递给 worker 上下文。

// create a 32mb "file" and fill it.
var uint8array = new uint8array(1024*1024*32); // 32mb
for (var i = 0; i < uint8array .length; ++i) {
  uint8array[i] = i;
}
worker.postmessage(uint8array.buffer, [uint8array.buffer]);

生成subworker

如果需要的话 worker 能够生成更多的 worker。这样的被称为 subworker，它们必须托管在与父页面相同的源内。同理，subworker 解析 uri 时会相对于父 worker 的地址而不是自身的页面。这使得 worker 容易监控它们的依赖关系。 chrome 目前并不支持subworker。

嵌入式 worker

目前没有一种「官方」的方法能够像<script>元素一样将 worker 的代码嵌入的网页中。但是如果一个<script>元素没有src 特性，并且它的type特性没有指定成一个可运行的 mime-type，那么它就会被认为是一个数据块元素，并且能够被 javascript 使用。「数据块」是 html5 中一个十分常见的特性，它可以携带几乎任何文本类型的数据。所以，你能够以如下方式嵌入一个 worker：

<!doctype html>
<html>
<head>
<meta charset="utf-8" />
<title>mdn example - embedded worker</title>
<script type="text/js-worker">
  // 该脚本不会被 js 引擎解析，因为它的 mime-type 是 text/js-worker。
  var myvar = "hello world!";
  // 剩下的 worker 代码写到这里。
</script>
<script type="text/javascript">
  // 该脚本会被 js 引擎解析，因为它的 mime-type 是 text/javascript。
  function pagelog (smsg) {
    // 使用 fragment：这样浏览器只会进行一次渲染/重排。
    var ofragm = document.createdocumentfragment();
    ofragm.appendchild(document.createtextnode(smsg));
    ofragm.appendchild(document.createelement("br"));
    document.queryselector("#logdisplay").appendchild(ofragm);
  }
</script>
<script type="text/js-worker">
  // 该脚本不会被 js 引擎解析，因为它的 mime-type 是 text/js-worker。
  onmessage = function (oevent) {
    postmessage(myvar);
  };
  // 剩下的 worker 代码写到这里。
</script>
<script type="text/javascript">
  // 该脚本会被 js 引擎解析，因为它的 mime-type 是 text/javascript。
  // 在过去...：
  // 我们使用 blob builder
  // ...但是现在我们使用 blob...:
  var blob = new blob(array.prototype.map.call(document.queryselectorall("script[type=\"text\/js-worker\"]"), function (oscript) { return oscript.textcontent; }),{type: "text/javascript"});
  // 创建一个新的 document.worker 属性，包含所有 "text/js-worker" 脚本。
  document.worker = new worker(window.url.createobjecturl(blob));
  document.worker.onmessage = function (oevent) {
    pagelog("received: " + oevent.data);
  };
  // 启动 worker.
  window.onload = function() { document.worker.postmessage(""); };
</script>
</head>
<body><div id="logdisplay"></div></body>
</html>

现在，嵌入式 worker 已经嵌套进了一个自定义的document.worker属性中。

超时与间隔

worker 能够像主线程一样使用超时与间隔。这会十分有用，比如说，如果你想让 worker 线程周期性而并非不间断的运行代码。

终止 worker

如果你想立即终止一个运行中的 worker，可以调用 worker 的terminate()方法：

myworker.terminate();

worker 线程会被立即杀死，不会留下任何机会让它完成自己的操作或清理工作。

workers 也可以调用自己的nsiworkerscope.close()方法来关闭自己：

self.close();

处理错误

当 worker 出现运行时错误时，它的onerror事件处理函数会被调用。它会收到一个实现了errorevent接口名为error的事件。该事件不会冒泡，并且可以被取消；为了防止触发默认动作，worker 可以调用错误事件的preventdefault()方法。错误事件拥有下列三个它感兴趣的字段：

message

可读性良好的错误消息。

filename

发生错误的脚本文件名。

lineno

发生错误时所在脚本文件的行号。

访问 navigator 对象

workers 可以在它的作用域内访问navigator对象。它含有如下能够识别浏览器的字符串，就像在普通脚本中做的那样：

• appname
• appversion
• platform
• useragent

引入脚本与库

worker 线程能够访问一个全局函数，importscripts()，该函数允许 worker 将脚本或库引入自己的作用域内。你可以不传入参数，或传入多个脚本的 uri 来引入；以下的例子都是合法的：

importscripts();                        /* 什么都不引入 */
importscripts('foo.js');                /* 只引入 "foo.js" */
importscripts('foo.js', 'bar.js');      /* 引入两个脚本 */

浏览器将列出的脚本加载并运行。每个脚本中的全局对象都能够被 worker 使用。如果脚本无法加载，将抛出network_error异常，接下来的代码也无法执行。而之前执行的代码(包括使用window.settimeout()延迟执行的代码)却依然能够使用。importscripts()之后的函数声明依然能够使用，因为它们始终会在其他代码之前运行。注意：脚本的下载顺序不固定，但执行时会按照你将文件名传入到importscripts()中的顺序。这是同步完成的；直到所有脚本都下载并运行完毕，importscripts()才会返回。

例子

本节提供了几个如何使用 dom worker 的例子。

在后台执行运算

worker 的一个优势在于能够执行处理器密集型的运算而不会阻塞 ui 线程。在下面的例子中，worker 用于计算斐波那契数。

javascript 代码

下面的 javascript 代码保存在「fibonacci.js」文件中，与下一节的 html 文件关联。

var results = [];
function resultreceiver(event) {
  results.push(parseint(event.data));
  if (results.length == 2) {
    postmessage(results[0] + results[1]);
  }
}
function errorreceiver(event) {
  throw event.data;
}
onmessage = function(event) {
  var n = parseint(event.data);
  if (n == 0 || n == 1) {
    postmessage(n);
    return;
  }
  for (var i = 1; i <= 2; i++) {
    var worker = new worker("fibonacci.js");
    worker.onmessage = resultreceiver;
    worker.onerror = errorreceiver;
    worker.postmessage(n - i);
  }
 };

worker 将属性onmessage设置为一个函数，当 worker 对象调用postmessage() 时该函数会接收到发送过来的信息。(注意，这么使用并不等同于定义一个同名的全局变量，或是定义一个同名的函数。var onmessage与function onmessage将会定义与该名字相同的全局属性，但是它们不会注册能够接收从创建 worker 的网页发送过来的消息的函数。) 这会启用递归，生成自己的新拷贝来处理计算的每一个循环。

html 代码

<!doctype html>
<html>
  <head>
    <meta charset="utf-8"  />
    <title>test threads fibonacci</title>
  </head>
  <body>
  <div id="result"></div>
  <script language="javascript">
    var worker = new worker("fibonacci.js");
    worker.onmessage = function(event) {
      document.getelementbyid("result").textcontent = event.data;
      dump("got: " + event.data + "\n");
    };
    worker.onerror = function(error) {
      dump("worker error: " + error.message + "\n");
      throw error;
    };
    worker.postmessage("5");
  </script>
  </body>
</html>

网页创建了一个div元素，id 为result， 用它来显示运算结果，然后生成 worker。在生成 worker 后，onmessage处理函数配置为通过设置div元素的内容来显示运算结果，然后onerror处理函数被设置为转储错误信息。最后，向 worker 发送一条信息来启动它。