Web worker 与JS中异步编程的对比

0.从一道题说起

var t = true;

setTimeout(function(){ t = false; }, 1000);

while(t){ }

alert('end');

问，以上代码何时alert“end”呢？
测试一下：答案是：永远都不会alert。

解析：JavaScript引擎是单线程的，事件触发排队等候。所有任务按照触发时间先后排队处理。
上例中，排队的顺序状态是：

| var t=true ; | while(t){}; | alert(‘end’); |

在1000ms之后，setTimeout函数也加入队列。
while(t){ }无限循环阻塞了单线程，不管排到后面的代码执行时间有多短，后面的代码无法执行，一直阻塞下去。

1.浏览器线程

浏览器有这么几大线程：UI渲染线程（用于页面的渲染），javascript引擎线程（用于处理js），GUI事件触发线程（用于交互）。

有时会开启的线程：http传输线程，定时触发线程（定时器）

它们之间的关系是什么呢？

（1）UI渲染线程与 javascript引擎线程互斥

由于javascript可以操纵页面的DOM，所以如果UI渲染线程与javascript引擎线程
不互斥的话，在UI渲染线程进行页面渲染的同时，javascript引擎线程进行DOM修改，最终会造成DOM状态不一致的现象。所以，当javascript引擎线程运行的时候，UI渲染线程处于冻结状态。

（2）javascript引擎线程与 GUI事件触发线程（用于交互）异步

浏览器开启事件触发线程，等待用户动作，事件触发线程解析为响应事件，转移到javascript引擎线程，排队等候，等待javascript引擎的处理。

（3）javascript引擎线程与 http传输线程异步

网页get，post等请求，xhr异步请求都通过http传输线程，传送到javascript引擎排队，等候处理。

（4）javascript引擎线程与定时触发线程（定时器）异步

setTimeout(),setInterval()由单独的线程定时触发线程触发，传送到javascript引擎排队等候，等待处理。

上述的所有的异步操作有不同的浏览器分配线程执行，那个先执行完就先将那个加入到异步队列中，利用事件的轮询执行异步队列中的回调函数

2.xhr异步是障眼法

我们来做一个试验：

客户端js代码

//jquery封装的ajax请求，请求http://localhost:3000/login页面

 $.ajax({

        type: "post",

        url: "http://localhost:3000/login",

        dataType: "json",

        data:{ username: username, password: password },

        success: function(data){

            if(data){

               if(data.message=="i202"){

                   alert('密码错误，请重新输入');

                   window.location.href="login";

               }else if(data.message=="i200"){

                    alert('登陆成功');

                    window.location.href="index";

                }

                else{

                    alert('没有这个用户名');

                   window.location.href="login";

                 }

            } else{

            }

        }

    });

    //这里有一个无限循环

    while(1){}

后端Node.js代码：

//后台对post的响应

router.post('/login', function (req, res, next) {

    sleep(1000);

    res.send({status:"success", message:"i200"});

});

/**

 * 模拟sleep

 * @param sleepTime

 */

function sleep(sleepTime) {

    for(var start = +new Date; +new Date - start <= sleepTime; ) { }

}

前台将永远不会alert(“登陆成功”)。浏览器通过http线程收到xhr响应，但是转到javascript线程等待执行。javascript单线程，一次只能处理一个任务。第一个任务无限循环，后面的任务全部阻塞。

xhr异步编程实际上是一种障眼法。

3.定时器时间不准

（1）时间不准1

 setTimeout(function () { while (true) { } }, 1000);

        setTimeout(function () { alert('end 2'); }, 2000);

        setTimeout(function () { alert('end 1'); }, 100);

        alert('end');

运行这段代码。运行结果是alert(‘end’) alert(‘end 1’)。

前两个定时器并不能如约在规定的时间点执行哦。

（2）时间不准2

setTimeout(function(){

   /* 代码块... */

   setTimeout(arguments.callee, 10);

}, 10);  

setInterval(function(){

   /*代码块... */

 }, 10);

两个定时器，本想实现相同的功能：每十秒触发一次定时器。

但是实际上，setTimeout在10ms后才加入js执行队列，排队等待。所以每两次定时器触发的时间间隔可能 > 10ms。

setInterval每10s就向js执行队列添加一个setInterval事件等待执行。前面的setInterval事件可能被它之前的事件阻塞，导致执行晚了几拍。那么没两次定时时间触发的时间间隔可能 <10ms 。

4.web worker 才是真正多线程

来吧，试验一下:

index.html

<!DOCTYPE html>

<html>

<head lang="en">

    <meta charset="UTF-8">

    <title></title>

</head>

<body>

<script src="js/Fthread.js"></script>

</body>

</html>

Fthread.js

//这里创建一个webworker就是开一个新的线程

var worker=new Worker('js/Sthread.js');//创建子线程

//这里接收新的线程传来的data

worker.onmessage = function(event) {

    console.log(event.data);

};

//这个将会触发向子进程的请求

worker.postMessage("begin");

//构造一个无限循环

//setTimeout(function () { while (true) { } }, 1000);该定时器不会阻塞线程的交互

Sthread.js

//这里占有一个新线程，向主线程发送消息

postMessage('hello');

//实现之前的一个实例，看是否阻塞

setTimeout(function () { console.log('end 2'); }, 2000);

setTimeout(function () { console.log('end 1'); }, 100);
worker.onmessage = function(event) {
    console.log(event.data);
};

console.log('end');

运行结果：

end

hello  //这是两个线程数据的传送，可以不看end1 end2
begin

end1

end2

hello没有被定时器异步阻塞，因为人家是在子线程运行滴。这才是多线程嘛。JS中的异步虽然也有开线程进行处理相关的操作，但是其回调函数还是需要通过主线程轮询执行，因而并不是完全的多线程。

webworker是基于浏览器引擎的,为了防止出现像C++之类的的多线程之间的竞态、死锁等现象，Web Worker有如下限制：

同源策略限制
不能访问页面DOM和其他资源
浏览器实现程度不同

同时web worker线程与主线程不共享作用域（只是进行简单消息传递而非数据的引用），这也会有问题当两者在进行消息通讯时会将同一个变量赋值两次，导致内存的占用增大，可以通过对大的数据集利用Transferable对象，进行所有权的传递，当数据传递出去后，原来的线程中将对该数据集失去访问的权限，这样可以避免作用域共享带来的问题，当然，所有权的传递是双向的。

我们可以在worker内部做这些事情：

可以执行网络操作（Ajax、Web Sockets）
可以使用定时器（set/clearTimeout()、set/clearInterval()）
访问某些重要全局变量及功能的复本（navigator、location、JSON、applicationCache）
可以使用importScrips()加载额外js脚本

Web worker有两种形式一个是共享web worker（多对一，通过端口号进行区分），另一个是专用 web worker(实现一对一)，上面的那个例子就是专用web worker的例子。

下面举一个共享web worker 的例子：

1、创建共享worker

var worker = new SharedWorker('scripts/worker.js');

2、每个主程序利用端口号区分（多个主程序的初始化是一样的，只是在初始化时分配的端口不同）

//demo.js

var worker = new SharedWorker('scripts/worker.js');

worker.port.addEventListener('message', function(e){

  console.log(e.data); //

}, false);

worker.port.start();启动web worker，初始化端口

3、worker线程中的内容

//worker.js

function calculate(){

  var ret = 0;

  for(var i = 1; i <= 1e9; i++){

    ret += i;

  }

  return ret;

}

addEventListener('connect', function(e){

  var port = e.ports[0];//用于获取连接分配的端口,区分主线程

  port.start();

  port.postMessage(calculate());

});

4、其他的使用如终止web worker有两种方式，使用和专用线程是一样的

//主线程

worker.terminate();

//工作线程

close();

转载请注明出处;http://www.cnblogs.com/heshan1992/p/6698069.html