Javascript 回调访问全局对象节点上的子进程

在节点中处理npm模块并访问另一个为我进行计算的文件。问题是，当打开时。消息事件/回调我不确定它实际上是什么，但我试图访问全局变量，它说它是未定义的。如果有人有，可以有一个很好的解释解决方案

        _addBlock(newBlock)
        {
                newBlock.previousHash = this._getLatestBlock().hash;
                 var child = 
      childProcess.fork('C:\\Users\\Yoana\\WebstormProjects\\ChildProcess\\mining1.js'
               );
               child.on('message', function(newBlock)
               {
                // Receive results from child process
                console.log('received: ' , newBlock);
                this.chain.push(newBlock);
            })

            // Send child process some work
            child.send(newBlock);

    }

---

它说this.chain.push未定义。方法_addBlock是类区块链的一部分，并且该.chain是全局可访问的

我不确定您使用的是哪种型号，即带有集群本机模块的node.js master/worker体系结构还是带有消息传递的child_process本机模块，顺便说一句，尽管不建议使用共享全局模块（如何处理共享内存？如何处理受保护内存？），但您可以通过以下方式：

global.GlobalBotFactory = function() {
        if (typeof(instance)=="undefined")
            instance = new MyClass(options);
        return instance;
    } 

然后你可以在其他文件中引用它，比如

this.instance = GlobalBotFactory(); // the shared factory instance

但这种方法尽管有效，但可能会导致以下几个问题：

• 并发变量修改
• 共享内存损坏
• 读写器问题

因此，我强烈建议遵循节点

集群

模块和主/辅方法，然后进行消息传递：

/// node clustering
const cluster = require('cluster');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) { // master node
    var masterConfig=require('./config/masterconfig.json');

    // Fork workers.
    var maxCPUs = masterConfig.cluster.worker.num;
    maxCPUs=(maxCPUs>=numCPUs)?numCPUs:maxCPUs;

    for (let i = 0; i < maxCPUs; i++) {
        const worker=cluster.fork();
    }

    var MasterNode=require('./lib/master');
    var master= new MasterNode(masterConfig);
    master.start()
    .then(done=> {
        console.log(`Master ${process.pid} running on ${masterConfig.pubsub.node}`);
    })
    .catch(error=> {
        console.error(`Master ${process.pid} error`,error);
    });
}
else if (cluster.isWorker) { // worker node
    var workerConfig=require('./config/workerconfig.json');
    var WorkerNode=require('./lib/worker');
    var worker= new WorkerNode(workerConfig);
    worker.start()
    .then(done=> {
        console.log(`Worker ${process.pid} running on ${workerConfig.pubsub.node}`);
    })
    .catch(error=> {
        console.error(`Worker ${process.pid} error`,error);
    });
}

///节点群集
const cluster=require（'cluster'）；
const numpus=require（'os'）.cpus（）.length；
if（cluster.isMaster）{//master节点
var masterConfig=require（'./config/masterConfig.json'）；
//叉工。
var maxCPUs=masterConfig.cluster.worker.num；
maxCPU=（maxCPU>=numpus）？numpus:maxCPU；
for（设i=0；i{
log（`Master${process.pid}在${masterConfig.pubsub.node}上运行）；
})
.catch（错误=>{
错误（`Master${process.pid}error`，error）；
});
}
else if（cluster.isWorker）{//worker节点
var workerConfig=require（'./config/workerConfig.json'）；
var WorkerNode=require（'./lib/worker'）；
var worker=新WorkerNode（workerConfig）；
worker.start（）
。然后（完成=>{
log（`Worker${process.pid}在${workerConfig.pubsub.node}上运行）；
})
.catch（错误=>{
错误（`Worker${process.pid}error`，error）；
});
}

对于消息传递部分，请小心，因为您将处理异步分叉过程，并且在node.js中不保证消息会被传递，因此您需要一个确认逻辑，或者您可以使用pubsub方法（Redis将免费提供，请检查），顺便说一下

for (var i = 0; i < 2; i++) {
    var worker = cluster.fork();

    // Receive messages from this worker and handle them in the master process.
    worker.on('message', function(msg) {
      console.log('Master ' + process.pid + ' received message from worker ' + this.pid + '.', msg);
    });

    // Send a message from the master process to the worker.
    worker.send({msgFromMaster: 'This is from master ' + process.pid + ' to worker ' + worker.pid + '.'});
  }

for（变量i=0；i<2；i++）{
var-worker=cluster.fork（）；
//接收来自此工作进程的消息并在主进程中处理它们。
worker.on（'message'，函数（msg）{
console.log（'Master'+process.pid+'接收到来自worker'+this.pid+'的消息，msg）；
});
//从主进程向工作进程发送消息。
send（{msgFromMaster:'这是从master'+process.pid+'到worker'+worker.pid+'.}）；
}

---

这将分叉工作线程并侦听来自主线程或其他工作线程的传入消息。但请记住，交付逻辑取决于您。有关

子流程的更多信息，请参阅。发送

我不确定您使用的是哪种型号，即带有群集本机模块的node.js主/工作架构，或带有消息传递的子进程本机模块等，尽管共享全局，但不建议使用（如何处理共享内存？如何处理受保护内存？）

global.GlobalBotFactory = function() {
        if (typeof(instance)=="undefined")
            instance = new MyClass(options);
        return instance;
    } 

然后你可以在其他文件中引用它，比如

this.instance = GlobalBotFactory(); // the shared factory instance

但这种方法尽管有效，但可能会导致以下几个问题：

• 并发变量修改
• 共享内存损坏
• 读写器问题

因此，我强烈建议遵循节点

集群

模块和主/辅方法，然后进行消息传递：

/// node clustering
const cluster = require('cluster');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) { // master node
    var masterConfig=require('./config/masterconfig.json');

    // Fork workers.
    var maxCPUs = masterConfig.cluster.worker.num;
    maxCPUs=(maxCPUs>=numCPUs)?numCPUs:maxCPUs;

    for (let i = 0; i < maxCPUs; i++) {
        const worker=cluster.fork();
    }

    var MasterNode=require('./lib/master');
    var master= new MasterNode(masterConfig);
    master.start()
    .then(done=> {
        console.log(`Master ${process.pid} running on ${masterConfig.pubsub.node}`);
    })
    .catch(error=> {
        console.error(`Master ${process.pid} error`,error);
    });
}
else if (cluster.isWorker) { // worker node
    var workerConfig=require('./config/workerconfig.json');
    var WorkerNode=require('./lib/worker');
    var worker= new WorkerNode(workerConfig);
    worker.start()
    .then(done=> {
        console.log(`Worker ${process.pid} running on ${workerConfig.pubsub.node}`);
    })
    .catch(error=> {
        console.error(`Worker ${process.pid} error`,error);
    });
}

///节点群集
const cluster=require（'cluster'）；
const numpus=require（'os'）.cpus（）.length；
if（cluster.isMaster）{//master节点
var masterConfig=require（'./config/masterConfig.json'）；
//叉工。
var maxCPUs=masterConfig.cluster.worker.num；
maxCPU=（maxCPU>=numpus）？numpus:maxCPU；
for（设i=0；i{
log（`Master${process.pid}在${masterConfig.pubsub.node}上运行）；
})
.catch（错误=>{
错误（`Master${process.pid}error`，error）；
});
}
else if（cluster.isWorker）{//worker节点
var workerConfig=require（'./config/workerConfig.json'）；
var WorkerNode=require（'./lib/worker'）；
var worker=新WorkerNode（workerConfig）；
worker.start（）
。然后（完成=>{
log（`Worker${process.pid}在${workerConfig.pubsub.node}上运行）；
})
.catch（错误=>{
错误（`Worker${process.pid}error`，error）；
});
}

对于消息传递部分，请小心，因为您将处理异步分叉过程，并且在node.js中不保证消息会被传递，因此您需要一个确认逻辑，或者您可以使用pubsub方法（Redis将免费提供，请检查），顺便说一下

for (var i = 0; i < 2; i++) {
    var worker = cluster.fork();

    // Receive messages from this worker and handle them in the master process.
    worker.on('message', function(msg) {
      console.log('Master ' + process.pid + ' received message from worker ' + this.pid + '.', msg);
    });

    // Send a message from the master process to the worker.
    worker.send({msgFromMaster: 'This is from master ' + process.pid + ' to worker ' + worker.pid + '.'});
  }

for（变量i=0；i<2；i++）{
var-worker=cluster.fork（）；
//接收来自此工作进程的消息并在主进程中处理它们。
worker.on（'message'，函数（msg）{
console.log（'Master'+process.pid+'接收到来自worker'+this.pid+'的消息，msg）；
});
//从主进程向工作进程发送消息。
send（{msgFromMaster:'这是从master'+process.pid+'到worker'+worker.pid+'.}）；
}

这将是一项艰巨的工作