Nodejs线程池的设计与实现

开发 架构
本文介绍在nodejs线程模块的基础上,如何设计和实现一个线程池库(https://github.com/theanarkh/nodejs-threadpool或npm i nodejs-threadpool )。下面是线程池的总体架构。

[[347021]]

本文转载自微信公众号「编程杂技」,作者theanarkh。转载本文请联系编程杂技公众号。 

前言:之前的版本不方便开放,重新设计了一版nodejs的线程池库,本文介绍该库的一些设计和实现。

nodejs虽然提供了线程的能力,但是很多时候,往往不能直接使用线程或者无限制地创建线程,比如我们有一个功能是cpu密集型的,如果一个请求就开一个线程,这很明显不是最好的实践,这时候,我们需要使用池化的技术,本文介绍在nodejs线程模块的基础上,如何设计和实现一个线程池库(https://github.com/theanarkh/nodejs-threadpool或npm i nodejs-threadpool )。下面是线程池的总体架构。

设计一个线程池,在真正写代码之前,有很多设计需要考虑,大概如下:

1任务队列的设计,一个队列,多个线程互斥访问,或者每个线程一个队列,不需要互斥访问。

2 线程退出的设计,可以由主线程检测空闲线程,然后使子线程退出。或者子线程退出,通知主线程。空闲不一定是没有任务就退出,可以设计空闲时间达到阈值后退出,因为创建线程是有时间开销的。

3 任务数的设计,每个线程可以有个任务数,还可以增加一个总任务数,即全部线程任务数加起来

4 选择线程的设计,选择任务数最少的线程。

5 线程类型的设计,可以区分核心线程和预备线程,任务少的时候,核心线程处理就行。任务多也创建预备线程帮忙处理。

6 线程池类型的设计,cpu密集型的,线程数等于核数,否则自定义线程数就行。

7 支持任务的取消和超时机制,防止一个任务时间过长或者死循环。

本文介绍的线程池具体设计思想如下(参考java):

1 主线程维护一个队列,子线程的任务由子线程负责分发,不需要互斥访问,子线程也不需要维护自己的队列。

2 线程退出的设计,主线程负责检查子线程空闲时间是否达到阈值,是则使子线程退出。

3 任务数的设计,主线程负责管理任务个数并应有相应的策略。

4 选择线程的设计,选择任务数最少的线程。

5 线程类型的设计,区分核心线程和预备线程,任务少的时候,核心线程处理就行。任务多也创建预备线程帮忙处理。

6 线程池类型的设计,cpu密集型的,线程数等于核数,否则自定义线程数就行。

7 支持任务的取消和超时机制,超时或者取消的时候,主线程判断任务是待执行还是正在执行,如果是待执行则从任务队列中删除,如果是正在执行则杀死对应的子线程。下面我们看一下具体的设计。

1 主线程和子线程通信的数据结构

  1. // 任务类,一个任务对应一个id 
  2. class Work { 
  3.     constructor({workId, filename, options}) { 
  4.         // 任务id 
  5.         this.workId = workId; 
  6.         // 任务逻辑,字符串或者js文件路径 
  7.         this.filename = filename; 
  8.         // 任务返回的结果 
  9.         this.data = null
  10.         // 任务返回的错误 
  11.         this.error = null
  12.         // 执行任务时传入的参数,用户定义 
  13.         this.options = options; 
  14.     } 

主线程给子线程分派一个任务的时候,就给子线程发送一个Work对象。在nodejs中线程间通信需要经过序列化和反序列化,所以通信的数据结构包括的信息不能过多。

2 子线程处理任务逻辑

  1. const { parentPort } = require('worker_threads'); 
  2. const vm = require('vm'); 
  3. const { isFunction, isJSFile } = require('./utils'); 
  4.  
  5. // 监听主线程提交过来的任务 
  6. parentPort.on('message', async (work) => { 
  7.     try { 
  8.         const { filename, options } = work
  9.         let aFunction; 
  10.         if (isJSFile(filename)) { 
  11.             aFunction = require(filename); 
  12.         } else { 
  13.             aFunction = vm.runInThisContext(`(${filename})`); 
  14.         } 
  15.         if (!isFunction(aFunction)) { 
  16.             throw new Error('work type error: js file or string'); 
  17.         } 
  18.         work.data = await aFunction(options); 
  19.         parentPort.postMessage({event: 'done'work}); 
  20.     } catch (error) { 
  21.         work.error = error.toString(); 
  22.         parentPort.postMessage({event: 'error'work}); 
  23.     } 
  24. }); 
  25.  
  26. process.on('uncaughtException', (...rest) => { 
  27.     console.error(...rest); 
  28. }); 
  29.  
  30. process.on('unhandledRejection', (...rest) => { 
  31.     console.error(...rest); 
  32. }); 

子线程的逻辑比较简单,就是监听主线程分派过来的任务,然后执行任务,执行完之后通知主线程。任务支持js文件和字符串代码的形式。需要返回一个Promise或者async函数。用于用于通知主线程任务已经完成。

3 线程池和业务的通信

  1. // 提供给用户侧的接口 
  2. class UserWork extends EventEmitter { 
  3.     constructor({ workId }) { 
  4.         super(); 
  5.         // 任务id 
  6.         this.workId = workId; 
  7.         // 支持超时取消任务 
  8.         this.timer = null
  9.         // 任务状态 
  10.         this.state = WORK_STATE.PENDDING; 
  11.     } 
  12.     // 超时后取消任务 
  13.     setTimeout(timeout) { 
  14.         this.timer = setTimeout(() => { 
  15.             this.timer && this.cancel() && this.emit('timeout'); 
  16.         }, ~~timeout); 
  17.     } 
  18.     // 取消之前设置的定时器 
  19.     clearTimeout() { 
  20.         clearTimeout(this.timer); 
  21.         this.timer = null
  22.     } 
  23.     // 直接取消任务,如果执行完了就不能取消了,this.terminate是动态设置的 
  24.     cancel() { 
  25.         if (this.state === WORK_STATE.END || this.state === WORK_STATE.CANCELED) { 
  26.            return false
  27.         } else { 
  28.             this.terminate(); 
  29.             return true
  30.         } 
  31.     } 
  32.     // 修改任务状态 
  33.     setState(state) { 
  34.         this.state = state; 
  35.     } 

业务提交一个任务给线程池的时候,线程池会返回一个UserWork类,业务侧通过UserWork类和线程池通信。

4 管理子线程的数据结构

  1. // 管理子线程的数据结构 
  2. class Thread { 
  3.     constructor({ worker }) { 
  4.         // nodejs的Worker对象,nodejs的worker_threads模块的Worker 
  5.         this.worker = worker; 
  6.         // 线程状态 
  7.         this.state = THREAD_STATE.IDLE; 
  8.         // 上次工作的时间 
  9.         this.lastWorkTime = Date.now(); 
  10.     } 
  11.     // 修改线程状态 
  12.     setState(state) { 
  13.         this.state = state; 
  14.     } 
  15.     // 修改线程最后工作时间 
  16.     setLastWorkTime(time) { 
  17.         this.lastWorkTime = time
  18.     } 

线程池中维护了多个子线程,Thread类用于管理子线程的信息。

5 线程池 线程池的实现是核心,我们分为几个部分讲。

5.1 支持的配置

  1. constructor(options = {}) { 
  2.         this.options = options; 
  3.         // 子线程队列 
  4.         this.workerQueue = []; 
  5.         // 核心线程数 
  6.         this.coreThreads = ~~options.coreThreads || config.CORE_THREADS; 
  7.         // 线程池最大线程数,如果不支持动态扩容则最大线程数等于核心线程数 
  8.         this.maxThreads = options.expansion !== false ? Math.max(this.coreThreads, config.MAX_THREADS) : this.coreThreads; 
  9.         // 超过任务队列长度时的处理策略 
  10.         this.discardPolicy = options.discardPolicy ? options.discardPolicy : DISCARD_POLICY.NOT_DISCARD; 
  11.         // 是否预创建子线程 
  12.         this.preCreate = options.preCreate === true
  13.         // 线程最大空闲时间,达到后自动退出 
  14.         this.maxIdleTime = ~~options.maxIdleTime || config.MAX_IDLE_TIME; 
  15.         // 是否预创建线程池 
  16.         this.preCreate && this.preCreateThreads(); 
  17.         // 保存线程池中任务对应的UserWork 
  18.         this.workPool = {}; 
  19.         // 线程池中当前可用的任务id,每次有新任务时自增1 
  20.         this.workId = 0; 
  21.         // 线程池中的任务队列 
  22.         this.queue = []; 
  23.         // 线程池总任务数 
  24.         this.totalWork = 0; 
  25.         // 支持的最大任务数 
  26.         this.maxWork = ~~options.maxWork || config.MAX_WORK; 
  27.         // 处理任务的超时时间,全局配置 
  28.         this.timeout = ~~options.timeout; 
  29.         this.pollIdle(); 
  30.     } 

上面的代码列出了线程池所支持的能力。

5.2 创建线程

  1. newThread() { 
  2.         const worker = new Worker(workerPath); 
  3.         const thread = new Thread({worker}); 
  4.         this.workerQueue.push(thread); 
  5.         const threadId = worker.threadId; 
  6.         worker.on('exit', () => { 
  7.             // 找到该线程对应的数据结构,然后删除该线程的数据结构 
  8.             const position = this.workerQueue.findIndex(({worker}) => { 
  9.                 return worker.threadId === threadId; 
  10.             }); 
  11.             const exitedThread = this.workerQueue.splice(position, 1); 
  12.             // 退出时状态是BUSY说明还在处理任务(非正常退出) 
  13.             this.totalWork -= exitedThread.state === THREAD_STATE.BUSY ? 1 : 0; 
  14.         }); 
  15.         // 和子线程通信 
  16.         worker.on('message', (result) => { 
  17.             const { 
  18.                 work
  19.                 event, 
  20.             } = result; 
  21.             const { data, error, workId } = work
  22.             // 通过workId拿到对应的userWork 
  23.             const userWork = this.workPool[workId]; 
  24.             // 不存在说明任务被取消了 
  25.             if (!userWork) { 
  26.                 return
  27.             } 
  28.             // 修改线程池数据结构 
  29.             this.endWork(userWork); 
  30.  
  31.             // 修改线程数据结构 
  32.             thread.setLastWorkTime(Date.now()); 
  33.  
  34.             // 还有任务则通知子线程处理,否则修改子线程状态为空闲 
  35.             if (this.queue.length) { 
  36.                 // 从任务队列拿到一个任务交给子线程 
  37.                 this.submitWorkToThread(thread, this.queue.shift()); 
  38.             } else { 
  39.                 thread.setState(THREAD_STATE.IDLE); 
  40.             } 
  41.  
  42.             switch(event) { 
  43.                 case 'done'
  44.                     // 通知用户,任务完成 
  45.                     userWork.emit('done', data); 
  46.                     break; 
  47.                 case 'error'
  48.                     // 通知用户,任务出错 
  49.                     if (EventEmitter.listenerCount(userWork, 'error')) { 
  50.                         userWork.emit('error', error); 
  51.                     } 
  52.                     break; 
  53.                 default: break; 
  54.             } 
  55.         }); 
  56.         worker.on('error', (...rest) => { 
  57.             console.error(...rest); 
  58.         }); 
  59.         return thread; 
  60.     } 

创建线程,并保持线程对应的数据结构、退出、通信管理、任务分派。子线程执行完任务后,会通知线程池,主线程通知用户。

5.3 选择线程

  1. selectThead() { 
  2.         // 找出空闲的线程,把任务交给他 
  3.         for (let i = 0; i < this.workerQueue.length; i++) { 
  4.             if (this.workerQueue[i].state === THREAD_STATE.IDLE) { 
  5.                 return this.workerQueue[i]; 
  6.             } 
  7.         } 
  8.         // 没有空闲的则随机选择一个 
  9.         return this.workerQueue[~~(Math.random() * this.workerQueue.length)]; 
  10.     } 

当用户给线程池提交一个任务时,线程池会选择一个空闲的线程处理该任务。如果没有可用线程则任务插入待处理队列等待处理。

5.4 提交任务

  1. // 给线程池提交一个任务 
  2.     submit(filename, options = {}) { 
  3.         return new Promise(async (resolve, reject) => { 
  4.             let thread; 
  5.             // 没有线程则创建一个 
  6.             if (this.workerQueue.length) { 
  7.                 thread = this.selectThead(); 
  8.                 // 该线程还有任务需要处理 
  9.                 if (thread.state === THREAD_STATE.BUSY) { 
  10.                     // 子线程个数还没有达到核心线程数,则新建线程处理 
  11.                     if (this.workerQueue.length < this.coreThreads) { 
  12.                         thread = this.newThread(); 
  13.                     } else if (this.totalWork + 1 > this.maxWork){ 
  14.                         // 总任务数已达到阈值,还没有达到线程数阈值,则创建 
  15.                         if(this.workerQueue.length < this.maxThreads) { 
  16.                             thread = this.newThread(); 
  17.                         } else { 
  18.                             // 处理溢出的任务 
  19.                             switch(this.discardPolicy) { 
  20.                                 case DISCARD_POLICY.ABORT:  
  21.                                     return reject(new Error('queue overflow')); 
  22.                                 case DISCARD_POLICY.CALLER_RUN: 
  23.                                     const workId = this.generateWorkId(); 
  24.                                     const userWork =  new UserWork({workId});  
  25.                                     userWork.setState(WORK_STATE.RUNNING); 
  26.                                     userWork.terminate = () => { 
  27.                                         userWork.setState(WORK_STATE.CANCELED); 
  28.                                     }; 
  29.                                     this.timeout && userWork.setTimeout(this.timeout); 
  30.                                     resolve(userWork); 
  31.                                     try { 
  32.                                         let aFunction; 
  33.                                         if (isJSFile(filename)) { 
  34.                                             aFunction = require(filename); 
  35.                                         } else { 
  36.                                             aFunction = vm.runInThisContext(`(${filename})`); 
  37.                                         } 
  38.                                         if (!isFunction(aFunction)) { 
  39.                                             throw new Error('work type error: js file or string'); 
  40.                                         } 
  41.                                         const result = await aFunction(options); 
  42.                                         // 延迟通知,让用户有机会取消或者注册事件 
  43.                                         setImmediate(() => { 
  44.                                             if (userWork.state !== WORK_STATE.CANCELED) { 
  45.                                                 userWork.setState(WORK_STATE.END); 
  46.                                                 userWork.emit('done', result); 
  47.                                             } 
  48.                                         }); 
  49.                                     } catch (error) { 
  50.                                         setImmediate(() => { 
  51.                                             if (userWork.state !== WORK_STATE.CANCELED) { 
  52.                                                 userWork.setState(WORK_STATE.END); 
  53.                                                 userWork.emit('error', error.toString()); 
  54.                                             } 
  55.                                         }); 
  56.                                     } 
  57.                                     return
  58.                                 case DISCARD_POLICY.OLDEST_DISCARD:  
  59.                                     const work = this.queue.shift(); 
  60.                                     // maxWork为1时,work会为空 
  61.                                     if (work && this.workPool[work.workId]) { 
  62.                                         this.cancelWork(this.workPool[work.workId]); 
  63.                                     } else { 
  64.                                         return reject(new Error('no work can be discarded')); 
  65.                                     } 
  66.                                     break; 
  67.                                 case DISCARD_POLICY.DISCARD: 
  68.                                     return reject(new Error('discard')); 
  69.                                 case DISCARD_POLICY.NOT_DISCARD: 
  70.                                     break; 
  71.                                 default:  
  72.                                     break; 
  73.                             } 
  74.                         } 
  75.                     } 
  76.                 } 
  77.             } else { 
  78.                 thread = this.newThread(); 
  79.             } 
  80.             // 生成一个任务id 
  81.             const workId = this.generateWorkId(); 
  82.  
  83.             // 新建一个UserWork 
  84.             const userWork =  new UserWork({workId});  
  85.             this.timeout && userWork.setTimeout(this.timeout); 
  86.  
  87.             // 新建一个work 
  88.             const work = new Work({ workId, filename, options }); 
  89.  
  90.             // 修改线程池数据结构,把UserWork和Work关联起来 
  91.             this.addWork(userWork); 
  92.  
  93.             // 选中的线程正在处理任务,则先缓存到任务队列 
  94.             if (thread.state === THREAD_STATE.BUSY) { 
  95.                 this.queue.push(work); 
  96.                 userWork.terminate = () => { 
  97.                     this.cancelWork(userWork); 
  98.                     this.queue = this.queue.filter((node) => { 
  99.                         return node.workId !== work.workId; 
  100.                     }); 
  101.                 } 
  102.             } else { 
  103.                 this.submitWorkToThread(thread, work); 
  104.             } 
  105.  
  106.             resolve(userWork); 
  107.         }) 
  108.     } 
  109.  
  110.     submitWorkToThread(thread, work) { 
  111.         const userWork = this.workPool[work.workId]; 
  112.         userWork.setState(WORK_STATE.RUNNING); 
  113.         // 否则交给线程处理,并修改状态和记录该线程当前处理的任务id 
  114.         thread.setState(THREAD_STATE.BUSY); 
  115.         thread.worker.postMessage(work); 
  116.         userWork.terminate = () => { 
  117.             this.cancelWork(userWork); 
  118.             thread.setState(THREAD_STATE.DEAD); 
  119.             thread.worker.terminate(); 
  120.         } 
  121.     } 
  122.  
  123.     addWork(userWork) { 
  124.         userWork.setState(WORK_STATE.PENDDING); 
  125.         this.workPool[userWork.workId] = userWork; 
  126.         this.totalWork++; 
  127.     } 
  128.  
  129.     endWork(userWork) { 
  130.         delete this.workPool[userWork.workId]; 
  131.         this.totalWork--; 
  132.         userWork.setState(WORK_STATE.END); 
  133.         userWork.clearTimeout();  
  134.     } 
  135.  
  136.     cancelWork(userWork) { 
  137.         delete this.workPool[userWork.workId]; 
  138.         this.totalWork--; 
  139.         userWork.setState(WORK_STATE.CANCELED); 
  140.         userWork.emit('cancel'); 
  141.     } 

提交任务是线程池暴露给用户侧的接口,主要处理的逻辑包括,根据当前的策略判断是否需要新建线程、选择线程处理任务、排队任务等,如果任务数达到阈值,则根据丢弃策略处理该任务。

5.5 空闲处理

  1. pollIdle() { 
  2.         setTimeout(() => { 
  3.             for (let i = 0; i < this.workerQueue.length; i++) { 
  4.                 const node = this.workerQueue[i]; 
  5.                 if (node.state === THREAD_STATE.IDLE && Date.now() - node.lastWorkTime > this.maxIdleTime) { 
  6.                     node.worker.terminate(); 
  7.                 } 
  8.             } 
  9.             this.pollIdle(); 
  10.         }, 1000); 
  11.     } 

当子线程空闲时间达到阈值后,主线程会杀死子线程,避免浪费系统资源。总结,这就是线程池具体的设计和实现,另外创建线程失败会导致主线程挂掉,所以使用线程的时候,最后新开一个子进程来管理该线程池。

 

责任编辑:武晓燕 来源: 编程杂技
相关推荐

2020-10-23 08:31:15

Nodejs-Ipc设计实现

2024-11-06 09:39:52

2017-05-04 16:33:58

Java线程池实践

2020-12-10 08:24:40

线程池线程方法

2013-05-23 15:59:00

线程池

2024-07-15 08:20:24

2009-07-22 09:39:18

CLR线程池

2012-02-01 11:20:23

Java线程

2020-03-05 15:34:16

线程池C语言局域网

2012-05-15 02:18:31

Java线程池

2021-06-06 23:40:53

线程池使用场景

2018-10-31 15:54:47

Java线程池源码

2018-04-27 10:35:08

Tomcat连接数线程池

2024-06-04 07:52:04

2021-05-26 11:30:24

Java线程池代码

2024-05-06 00:00:00

ThreadPool线程调度

2023-08-02 08:03:08

Python线程池

2020-08-20 07:54:58

Node多线程解密

2023-05-19 08:01:24

Key消费场景

2021-09-11 15:26:23

Java多线程线程池
点赞
收藏

51CTO技术栈公众号