node c++多线程插件构想

最近想写一个node的c++插件实现线程。提供的api使用回调并进行二次包装使其返回一个promise，并且要求需要在工作线程里执行的函数为async函数。如果是node7.0以下的版本，函数必须返回一个promise对象

目前还在构想api列表，我本身并不懂c++，感觉和学过的c#相差太大，总之就是非常难的感觉，很多地方完全不能理解。按照网上的hello world写出来发现不对，在官网查结果api改了，那个气啊。

构想的api现在只有几个

Thread=require('thread');                      //引用

new Thread(fn[async],args);                  //创建一个线程

thr.id;                                                     //windows下thr的managedId

thr.start();                                              //启动线程，返回一个promise对象，可用await接收

thr.abort();                                             //中断线程，将触发promise的reject状态

thr.sleep(ms);                                         //阻塞线程，默认永久阻塞

thr.restart();                                           //重开阻塞的线程，如果没有阻塞，忽略此操作

thr.wait();                                               //当前线程等待该线程执行完毕

//用于不支持async/await的node版本

Thread.pool;                                           //获取线程池

pool.maxSize;                                         //get/set 线程池的最大尺寸

pool.minSize;                                          //get/set 线程池的最小尺寸

pool.workingCount;                                 //get 正在执行任务的工作线程数

pool.run(fn[async],args);                        //启动工作线程执行函数，返回promise

Thread.current;                                       //获取当前线程，允许在线程池里使用

//线程池里获取的线程不支持abort函数

Thread.lock(src);                                     //为资源上锁，同一时间只允许一个线程访问该资源

目前这只是一个构想，还没有实现，我在学习c++，最近因为考驾照比较忙，如果实现了，就可以如下使用代码。

const Thread = require(`thread`);
const threadPool = Thread.pool;

threadPool.run(async function (src) {
    try {
        let txt = require('fs').readFileSync(src)
        console.log(`结果为${result}`);
    }
    catch (err) {
        throw err;
    }
}, '1.txt');

//这里是一个死循环，在单线程的node里是绝对没有办法执行上面的console.log操作的
//但是这里使用多线程，使用子线程打印，主线程一直打印占用
while (true) {
    console.log(`主线程一直被占用`);
}

上面的例子还演示了fs.readFile可以写成如下

 const Thread = require(`thread`);
 const threadPool = Thread.pool;

 /**
  * @param {String} src 要读取的文件路径
  * @param {String} encode 编码
  * @return {Promise}
  */
 // 这个函数虽然直接返回promise，但是由于理解方便，所有返回promise的函数都用async标记
 async function readFile(...args) {
     return threadPool.run(async () => {
         try {
             let result = require('fs').readFileSync(...args);
             return result;
         }
         catch (err) {
             throw err;
         }
     })
 }

 /**
  * 这个函数使用自带的fs.readFile改写成promise的形式
  * 但还是上面的同步的方式看起来更舒服
  */
 async function readFile(src, encode) {
     return new Promise((resolve, reject) => {
         let args = [src];
         if (encode) args.push(encode);
         args.push((err, data) => {
             if (err) reject(err);
             else resolve(data);
         })

         require('fs').readFile(...args);
     })
 }

 //最终用async函数调用
 (async function main() {
     try {
         let txt = await readFile('1.txt', 'utf-8');
         console.log(txt);
     }
     catch (err) {
         console.log(`出错啦，信息:${err.message}`);
     }
 } ());