Question

我有一个专门的Webworker，一旦收到一个启动信号进入一个长循环，并根据一些启动设置循环将＆＃34;产生＆＃34;在给定的执行点。

这是我的代码的简化版

var mode = null;
var generator = null;

function* loop() {

    for(var i=0;i<10000;i++) {
        //Do stuff
        for(var j=0;j<10000;j++) {
            //Do stuff
            if( mode == 'inner' ){
                //Yield after each inner loop iteration
                yield 2;
            }
        }
        if( mode == 'outer' ){
            //Yield after each outer loop iteration
            yield 1;
        }
    }

    /*
    If mode is not inner or outer the function won't yield 
    and will process the whole loop in one shot
    */
    return null;

}

generator = loop();

self.onmessage = function(event) {

    var m = event.data;    
    if(m.operation == 'run') {
        mode = m.mode;
        generator.next();
    }

    if(m.operation == 'pause') {
        //Set a flag and check for it in the loop
    }
}

我想要做的是允许工作人员按需暂停，问题是，在循环中，工作人员不会处理消息并且消息不会被呼叫，所以我无法发送＆＃34;暂停＆＃34;设置标志的消息然后我在循环中检查该标志。

我想做的是让我的函数在每次迭代后产生，以允许工作线程处理消息队列，然后如果没有收到暂停信号则再次恢复该函数，但是，这感觉有点hacky。

有没有办法强制WebWorker处理消息队列而不离开循环或屈服？或者可能是一种设置标志而不通过onmessage（）的方法？

谢谢

Answer 1

是否有一种方法可以强制WebWorker处理消息队列而不离开循环或让步？还是不通过onmessage（）设置标志的方法？

不。工人是单线程的，就像主线程一样。一次只能执行一行，而且幸运的是没有goto。

此外，您的解决方案还有一个缺陷，那就是不会一直使用CPU。在loop yield之后，直到您在消息事件侦听器中调用.next后，它才会继续。我提出了async/await的替代方案：

function Timeout(time) {
    return new Promise(resolve=>setTimeout(resolve, time));
}
let mode = "inner";
async function loop() {
    for(var i=0;i<10000;i++) {
        //Do stuff
        for(var j=0;j<10000;j++) {
            //Do stuff
            if( mode == 'inner' ){
                await Timeout(0);
            }
        }
        if( mode == 'outer' ){
            await Timeout(0);
        }
    }
}
// or you can start it only after you receive the right message
const workerLoop = loop();
(async () {
  await workerLoop;
  self.postMessage("done");
})();

关于暂停，您还可以使用承诺：

let mode = "inner";
let pausePromise = null;
async function loop() {
    for(var i=0;i<1000;i++) {
        //Do stuff
        for(var j=0;j<1000;j++) {
            if(pausePromise) {
              console.log("Loop paused");
              await pausePromise;
              console.log("Loop resumed");
            }
        }
    }
}
let workerLoop = null;
self.onmessage = function(event) {
    var m = event.data;    
    if(m.operation == 'run') {
        mode = m.mode;
        if(!workerLoop) {
          workerLoop = loop();
        }
    }

    if(m.operation == 'pause') {
        if(workerLoop) {
          var listener = null;
          pausePromise = new Promise(resolve=>self.addEventListener("message", listener = (event)=>{
              if(event.data.operation=="run") {
                console.log("Resuming loop from promise.");
                self.removeEventListener("message", listener);
                pausePromise = null;
                resolve();
              }
          }))
        }
        else {
          console.warn("Not running!");
        }
    }
}

这有点脏，但是可以用。它是在JS小提琴中工作的：https://jsfiddle.net/Darker/pvy6fszL/16/

中断循环WebWorker

1 个答案: