标签: worker-thread

在Scala 2.8中,当我开始演员时,我可以通过消息传递进行通信.这反过来意味着我可以发送最终的Exit()消息或我认为适合我的协议的任何内容.

但是我如何检查演员是否退出？我可以很容易地想象自己有一个任务,其中一个主演员开始一些工人演员,然后只是等待答案,每次检查这是否是最终的答案(即任何演员仍在工作或他们都退出？).

当然,我可以让他们都发回"我已经完成"的消息,然后计算它们,但这在某种程度上是令人不满意的.

在测试工人演员的完成时,最佳做法是什么？

编辑#1

嘿伙计们,我正在考虑期货,但遇到了麻烦.有人可以解释为什么这段代码不起作用:

package test
import scala.actors.Futures._

object FibFut extends Application{

    def fib(i:Int):Int = 
        if(i<2)
            1
        else
            fib(i-1)+fib(i-2)

    val f = future{ fib(3) }

    println(f())    

}

如果我在future-body中定义函数fib,它就可以工作.它必须是范围的东西,但我没有上面的任何错误,它只是挂起.任何人？

编辑#2

似乎扩展应用程序并不是一个好方法.定义主要方法使一切正常.以下代码是我正在寻找的,所以Futures得到了大拇指:)

package test

import scala.actors.Futures._

object FibFut {

  def fib(i: Int): Int = if (i < 2) 1 else fib(i - 1) + fib(i - 2)

  def main(args: Array[String]) {

    val fibs = for (i <- 0 to 50) yield future { fib(i) }

    for (future …

有没有一个选项可以让主线程等待所有工作线程完成？
在下面的代码中，mainThread.js 只是创建了工作线程。
工人需要很长时间才能执行。
在这种情况下，我们如何指示主线程等待所有线程执行完毕？
类似于 java 中的 thread.join() 的东西。

主线程.js：

const {Worker, parentPort, workerData} = require('worker_threads');
const path = require('path');

const startWorker = function(path, workerData, callback) {
    //Create worker thread
    let worker = new Worker(path, {workerData});

    //Listen to events of the worker thread
    worker.on('message', (msg) => {
        callback(null, msg);
    });
    worker.on('error', callback);
    worker.on('exit', (code) => {
        if(code !== 0) {
            console.error(`Error: Non-zero exit code ${code}`)
        }
    });

    //Return the worker thread
    return worker;
};

console.log('This is Main Thread');

//Create …

节点 v10.16.3

我正在运行worker_threads节点官方文档中的示例。为了测试共享变量，我做了一些更改。这是一个例子

工作线程.js

const {
  Worker,
  isMainThread,
  parentPort,
  workerData
} = require("worker_threads");

let a = 10;

if (isMainThread) {
  module.exports = async function parseJSAsync(num) {
    return new Promise((resolve, reject) => {
      const worker = new Worker(__filename, {
        workerData: num
      });
      worker.on("message", resolve);
      worker.on("error", reject);
      worker.on("exit", code => {
        if (code !== 0)
          reject(new Error(`Worker stopped with exit code ${code}`));
      });

      for (let i = 0; i < num; i++) {
        console.log("master: ", a);
        a++;
      }
    });
  }; …

在 Nodejs 中，使用 Express 作为服务器，我将繁重的计算卸载到工作线程上。

在主应用程序中，我像这样调用工作线程：

// file: main.js

const { Worker } = require("worker_threads");

function runService(fileName, workerData) {
    return new Promise((resolve, reject) => {
        const worker = new Worker(fileName, { workerData });
        worker.on("message", resolve);
        worker.on("error", reject);
        worker.on("exit", code => {
            if (code !== 0)
                reject(new Error(`Worker stopped with exit code ${code}`));
        });
    });
}

router.get("/some_url", async function(req, res) {
    const result = await runService(
        "./path/to/worker.js",
        { query: req.query, user: req.user } // using { req } causes an error …

Nodejs 不能像 java 和 .net 那样有内置的线程 API。如果添加线程，语言本身的性质将发生变化。不可能将线程添加为一组新的可用类或函数。

Nodejs 10.x 添加了工作线程作为实验，现在自 12.x 起稳定。我浏览了几篇博客，但可能由于缺乏知识而不太了解。它们与线程有何不同。

我有一个工作人员创建 MessageChannel 并将端口之一发送到主线程

// worker1.js
const { parentPort, MessageChannel } = require('worker_threads');

const { port1, port2 } = new MessageChannel();

port1.on('message', (msg) => {
  console.log(msg);
})

parentPort.postMessage(port2, [port2]);

第二种类型的工作人员只是接收 MessagePort 并将数据发送到端口

// sub_worker.js
const { parentPort, MessageChannel } = require('worker_threads');

parentPort.on('message',  (port) => {
  port.postMessage('some data')
});

主线程代码

// main thread
const { Worker } = require('worker_threads');

const mw = new Worker('worker1.js');
mw.on('message', (port) => {
  for (let i = 0; i < 5; i++) {
    const w = new …

工人.js

async function main() {
  throw new Error('Bullocks!');
}

setTimeout(async () => {
  await main();
}, 1000);

main.js

const { Worker } = require('worker_threads');

const worker = new Worker('./worker.js');
worker.on('error', err => {
  console.log('error happened on the worker');
});

为什么 main.js 上的错误处理程序没有被调用，而只是打印错误。

(node:26000) UnhandledPromiseRejectionWarning: Error: Bullocks!

我已经使用了这个解决方案并且有效：当发生未处理的拒绝时抛出错误，但是是否有任何“正确”的解决方案？

(node:26000) UnhandledPromiseRejectionWarning: Error: Bullocks!

我的 Node 应用程序使用 AWS SDK，为了在本地模拟它，我使用 Jest 的手动模拟。基本上，我将 AWS SDK 的准系统模拟放在__mocks__文件夹中，以模拟我使用的方法 - 在 Jest 测试期间，主代码将调用此“AWS-SDK”。

这对于常规代码流来说效果很好。但是，当我调用工作线程时（我正在使用同步线程库，但这对于常规工作线程使用来说是正确的）-工作线程内部的代码在运行 Jest 测试时尝试调用真正的 AWS-SDK。

有没有一种方法可以让它也使用模拟的？此外，工作线程中设置的环境变量不会持续存在于调用者线程中 - 这是设计使然还是可以这样设置？

我想在 node.js 应用程序中创建一个工作线程，并将当前上下文传递给新线程，这样我就可以在新线程中访问我的变量和函数，是否有一个库可以支持它？如果不是，我至少可以在它们之间传递一个匿名函数吗？

我计划为 socket.io 房间提供工作线程。我在与房间的第一个连接上创建一个工作线程，然后设置 firebase 侦听器。

很遗憾。我在工作文件和我的主要源代码中有常见的导入。

我按照这篇文章允许通过worker_threads运行ts文件 - > https://wanago.io/2019/05/06/node-js-typescript-12-worker-threads/

不幸的是，我没有得到顶级等待，并且在启动工作线程时，出现以下错误。 error TS2451: Cannot redeclare block-scoped variable 'tslib_1'.\r\n"

这是我的 tsconfig.json

{
  "compilerOptions": {
    "target": "esnext",
    "lib": ["esnext"],
    "module": "commonjs",
    "importHelpers": true,
    "skipLibCheck": true,
    "esModuleInterop": true,
    "allowSyntheticDefaultImports": true,
    "moduleResolution": "node",
    "baseUrl": ".",
    "sourceMap": true,
    "declaration": false,
    "noImplicitAny": false,
  },
  "files": [
    "typings.d.ts"
  ],
}