使用ES6玩转多线程

一、需求

JS著名的Event Loop限制了使用多线程的想象力，这对于高并发IO操作是不错的选择，但对于高并发的CPU型运算，必然是捉襟见肘。

Event Loop

二、早期的NodeJs解决之道

依赖于强大的V8引擎，nodeJS可以借助于对系统底层的调用，利用子进程完成对并发计算的需求，体现在child_process和cluster这两个模块。
但进程的内存区不可共享，进程切换开销，及通过Binding Bridge的通信，将极大的限制NodeJS的工作效率！

三、ES6 的MessageChannel 是解决问题的突破口

MessageChannel和MessagePort

1. 演示代码（浏览器环境）：

var channel=new MessageChannel();
let book={id:1}
//默认：book将对序列化的方式进行发送
//port1发送时，由port2时行接收
channel.port1.postMessage(book);

//默认：event.data,是book对象的"深克隆对象"
channel.port2.onmessage=function (event) {
    console.log(event.data.id) //show 1
}

2. 分析：

此时，所有的处理工作都是在event loop的线程中执行，如果channel的两头分别是两个不同的线程，就可以完成多线程的通信重任了！

3. 未完成的笔记：
   后续会用一篇文章分析三种不同形式的postMessage参数情况。

四、先谈下Web Workers

由ES6引入的子线程的概念，可以使用new Worker(url)，将url指向的js代码，放入子线程中执行，详见代码（以浏览器环境为例）：

1. 在html文件中

    <script>
        //启动Worker子线程，并传入参数
        var worker=new Worker('sub.js',{name:'john'})
        //进行异常处理
        worker.onerror=function (err) {
            console.log(err.message)
        }
    </script>

2. 被子线程加载的代码 sub.js

//这里的代码将在子线程中执行
//注意：这里不是能访问document,window对象的，但可以访问location,navigator对象
var name=self.name //获取启动时传入的信息
throw new Error('name is recieved!')  //将在主线程中的worker.onerror中接收到
self.close() //强行关闭子线程（并不需要显示调用）

3. 运行结果

Uncaught Error: john is recieved!

五、父子线程通信

1. 原理：利用一个匿名管理（MessageChannel）,利用其port1,port2完成通讯
2. 代码（以浏览器环境为例）
   html中

   <script>
        //启动Worker子线程，并传入参数
        var worker=new Worker('sub.js',{name:'john'})

        //父线程向子线程发送
        worker.postMessage({name:"good js"})
        //等待子线程发送过来的数据
        worker.onmessage=function (event) {
            console.log(event.data)
        }
    </script>

sub.js(子线程)

//这里的代码将在子线程中执行
var name=self.name //获取启动时传入的信息
self.onmessage=function(event){
    //这里获取的是一个深克隆对象
    var book=event.data;
    book.id=1
    //子线程向父线程发送数据
    self.postMessage(book)
}

3. 运行结果

{name: "good js", id: 1}

六、postMessage的参数：

1. 默认情况下，会对参数时行序列化操作（要在接收方产生一个深克隆对象），但其能力要远强于JSON.stringify，表现在以下：
   （1）可以处理循环引用问题
   （2）处理一些js内置对象，如Set,Regexp等对象
   （3）能处理ArrayBuffer
   （4）能处理一些C++原生的对象，如：MessagePort
   但要注意：参数对象，如果带有方法时，处理时会抛出异常。
2. 当参数的类型为SharedArrayBuffer时，会将对象本身进行共享(共享内存区)

const sharedUint8Array = new Uint8Array(new SharedArrayBuffer(4));
worker.postMessage(sharedUint8Array);

3. 当postMessage加上可选的第二个参数（TransferList）时，也表示“共享内存区”，但在TransferList加以标明的对象，在发送完毕后，是不可以被使用的！

const uint8Array = new Uint8Array([ 1, 2, 3, 4 ]);
worker.postMessage(uint8Array, [ uint8Array.buffer ]);

此时uint8Array会以内存区的形式直接共享，但由于其在第二个参数中加以注明（成为TranserList的一部分），所以其在主线程中，是不可以再继续使用的。

4. TransferList的中的对象类型：
   只能是ArrayBuffer和MessagePort两种类型。

七、利用MessageChannel和MessagePort完成子线程间的通信。

1. 思路：在主线程中，将MessageChannel的port1和port2，分别以postMessage的参数发送到两个子线程，然后子线程利用收到的port，对channel进行发送和接收，从而完成子线程间的通信。
2. 代码：
   html:

    <script>
        //子线程通信用的channel
        var channel=new MessageChannel();
        //分别启动两个子线程
        var worker1=new Worker('sub1.js')
        var worker2=new Worker('sub2.js')
        //将port1和port2分别传递给子线程
        worker1.postMessage({port:channel.port1},[channel.port1])
        worker2.postMessage({port:channel.port2},[channel.port2])
    </script>

sub1.js和sub2.js

//接收从父线程发送过来的port
self.onmessage=function (event) {
    //利用port1进行发送到channel（此时port2上出现数据）
    event.data.port.postMessage("I am sub1 worker!")
  //利用port1监听channel（等待从port2发送过来的数据）
    event.data.port.onmessage=function (event) {
        console.log("in sub1:"+event.data)
    }
}

self.onmessage=function (event) {
    event.data.port.postMessage("I am sub2 worker!")
    event.data.port.onmessage=function (event) {
        console.log("in sub2:"+event.data)
    }
}

3. 运行结果：

in sub2:I am sub1 worker!
in sub1:I am sub2 worker!