ee-core：v2.0.3

介绍

ChildJob基于node.js子进程实现。触发任务时才会创建进程，任务执行完毕后，必须调用进程退出的方法：Ps.exit()， 否则进程无法退出，造成资源浪费。

优点：随用随取，用完释放，不过多占用电脑资源。

不足：频繁、大量创建任务时，会有启动进程的开销，业务略微延迟，可使用ChildPoolJob功能

使用方法

const { ChildJob } = require('ee-core/jobs');

const job = new ChildJob();

API列表

job.jobs

ee-core：v2.1.0

属性，返回通过exec创建的实例对象集合。

job.exec(filepath, params = {}, opt = {})

• filepath [String] - ./jobs 目录的相对路径；或者绝对路径。
• params [Object] - 传递的参数
• opt [Object] - 进程参数

启动一个新进程，执行一个job文件。

# 示例文件
# ./electron/service/example.js

/**
 * 执行任务
 */ 
doJob(jobId, action, event) {
  let res = {};
  let oneTask;
  const channel = 'controller.example.timerJobProgress';
  if (action == 'create') {
    // 执行任务及监听进度
    let eventName = 'job-timer-progress-' + jobId;
    const timerTask = job.exec('./jobs/example/timer', {jobId});
    timerTask.emitter.on(eventName, (data) => {
      Log.info('[main-process] timerTask, from TimerJob data:', data);
      // 发送数据到渲染进程
      event.sender.send(`${channel}`, data)
    })

    res.pid = timerTask.pid; 
    this.taskForJob[jobId] = timerTask;
  }
  if (action == 'close') {
    oneTask = this.taskForJob[jobId];
    oneTask.kill();
    event.sender.send(`${channel}`, {jobId, number:0, pid:0});
  }    

  return res;
}

job.execPromise(filepath, params = {}, opt = {})

ee-core：v2.1.0

job.execPromise('./jobs/example/timer', {jobId}).then(task => {
  let eventName = 'job-timer-progress-' + jobId;
  task.emitter.on(eventName, (data) => {
    // ...
  })
});

exec()的异步语法，启动一个新进程，异步执行一个job文件。

job.getPids()

ee-core：v2.1.0

获取当前pids数组。

EventEmitter

ChildJob继承于events模块，因此实例化后的对象，可以使用EventEmitter所有方法。如：on()

job.on(eventName, callback)

监听一个事件对象，执行回调。注：子进程（并发任务）同时有多个的情况下，可能无法区分来源。

# 示例文件
# ./electron/service/example.js
let eventName = 'job-timer-progress-' + jobId;
job.on(eventName, (data) => {
  // ...
})

# ./electron/jobs/timer.js
const Message = require('ee-core/message');

let childMessage = Message.childMessage;
let eventName = 'job-timer-progress-' + jobId;
childMessage.sendToMain(eventName, {jobId, number});

ForkProcess

通过exec() / execPromise() 返回的进程对象。

const myProc = job.exec('./jobs/example/timer', {jobId});

# or
job.runPromise('./jobs/example/timer', {jobId}).then(myProc => {
  let eventName = 'job-timer-progress-' + jobId;
  myProc.emitter.on(eventName, (data) => {
    // ...
  })
});

myProc.emitter

ee-core：v2.1.0

实例化后的EventEmitter (opens new window)模块对象。

• 方法列表：

emitter.addListener(eventName, listener)
emitter.emit(eventName[, ...args])
emitter.eventNames()
emitter.getMaxListeners()
emitter.listenerCount(eventName)
emitter.listeners(eventName)
emitter.off(eventName, listener)
emitter.on(eventName, listener)
emitter.once(eventName, listener)
emitter.prependListener(eventName, listener)
emitter.prependOnceListener(eventName, listener)
emitter.removeAllListeners([eventName])
emitter.removeListener(eventName, listener)
emitter.setMaxListeners(n)
emitter.rawListeners(eventName)
emitter[Symbol.for('nodejs.rejection')](err, eventName[, ...args])

• 使用

// 执行任务及监听进度
const myProc = job.exec('./jobs/example/timer', {jobId});
let eventName = 'job-timer-progress-' + jobId;
myProc.emitter.on(eventName, (data) => {
  // ...
})

myProc.child

通过child_process (opens new window)模块，fork (opens new window)出来的进程对象。

myProc.pid

子进程pid

myProc.dispatch(cmd, jobPath = '', params = {})

ee-core：v2.1.0

分发任务

myProc.callFunc(jobPath = '', funcName = '', ...params)

ee-core：v2.11.0

调用job中模块的方法

• 使用

myProc.callFunc('./jobs/example/timer', 'pause', params1, params2);
})

#### myProc.kill()
> ee-core：v2.1.0

- timeout [Int] - 默认 1000ms

kill子进程

#### myProc.sleep()
> ee-core：v2.1.0

sleep（仅Unix平台)

#### myProc.wakeup()
> ee-core：v2.1.0

wakeup (仅Unix平台)