最近看到一个实现异步方法转换为同步方法的库 deasync。正好看到有些场景可以用到，所以分析一下库的源代码。
这个库的源码在这里 deasync。最好是看了我上一篇的介绍 NodeJS debug C++ 的那篇文章，同样的内容我就不注释了。

源代码

这其实是一个 NodeJS 的 C++ 的插件。核心代码只有下面的一些：

#include <uv.h>
#include <v8.h>
#include <napi.h>
#include <uv.h>

using namespace Napi;

Napi::Value Run(const Napi::CallbackInfo& info) {
  Napi::Env env = info.Env();
  Napi::HandleScope scope(env);
  uv_run(uv_default_loop(), UV_RUN_ONCE);
  return env.Undefined();
}

static Napi::Object init(Napi::Env env, Napi::Object exports) {
  exports.Set(Napi::String::New(env, "run"), Napi::Function::New(env, Run));
  return exports;
}

NODE_API_MODULE(deasync, init)

这里面用的是 N-API 的接口，但这个库里面的代码不能正常的编译出 Debug 模块，所以把这核心代码拿出来又写了一个新的库，然后重新编译即可。

源码分析

直接看代码：

#include <uv.h>
#include <v8.h>
#include <napi.h>
#include <node.h>

using namespace Napi;

/**
 * CallbackInfo 是一个参数类，如果有调用方法有传参，可以通过 info[0]、info[1]、info.Length() 来获取
 */
Napi::Value Run(const Napi::CallbackInfo &info)
{
    // 每个调用方法都能通过 CallbackInfo 类获取到 env，也可以获取 Context ，通过 env 获取到值和操作
    Napi::Env env = info.Env();

    // HandleScope 句柄作用域，控制对象的生命周期，是 napi_open_handle_scope 的封装
    // 当一个句柄作用域对象被删除时，或者这个 Run 函数结束了，作用域内的对象就算被别的地方引用，也会被垃圾回收器随时释放
    Napi::HandleScope scope(env);

    // uv_runL 运行 Event Loop，这里加了 UV_RUN_ONCE，说明只轮询 I/O 一次
    // 如果是 UV_RUN_NOWAIT 标识，轮询 I/O 一次但不会阻塞
    // 如果 uv_run 里面没有待执行的任务回调，就会等待，算出 timeout 时间，这里就是异步转同步的关键
    // 然后调用 epoll_pwait 去让整个程序等待
    // 返回是否成功
    // -----
    // uv_default_loop: 返回初始化过的默认 event loop
    // 返回一个 loop 结构体，记录了初始化过的 loop 信息
    uv_run(uv_default_loop(), UV_RUN_ONCE);

    // 返回 js value: undefined
    return env.Undefined();
}

static Napi::Object init(Napi::Env env, Napi::Object exports)
{
    // 给 Object 对象 exports 设置属性， exports 相当于 js 中的 object {}，相当于
    // const exports = {}
    // exports.run = function Run() { ... }
    exports.Set(Napi::String::New(env, "run"), Napi::Function::New(env, Run));
    return exports;
}

NODE_API_MODULE(NODE_GYP_MODULE_NAME, init)

uv_run 显式的运行一次 EventLoop, 并且暴露 run 方法，然后用在下面的 js 代码中：

const deasyncAddon = require('./build/Debug/hello.node')
const loopWhile = function (pred) {
    while (pred()) {
        process._tickCallback()
        if (pred()) deasyncAddon.run()
    }
}

先不管 process._tickCallback()，看起来就像是写了一个阻塞的循环代码，只有 pred() 或者 isEnd() 结束后才会中断：

const wait = function (time) {
    const start = Date.now()
    const isEnd = () => (Date.now() - start) < time
    while (isEnd()) {}
}

但几乎完全不一样。pred 这个回调方法完成后，就会终止，而不像 wait 方法让整个线程都阻塞，干不了其它事情。

在 loopWhite 方法中， process._tickCallback() 的使用也很巧妙，在 NodeJS 源码中有说：

process.nextTick = nextTick;
// Used to emulate a tick manually in the JS land.
// A better name for this function would be `runNextTicks` but
// it has been exposed to the process object so we keep this legacy name
process._tickCallback = runNextTicks;

在正常的代码中出现 _tickCallback()，则马上执行之前所有的 nextTicks 任务，接着执行同步任务。但我看 runNextTicks 源码的时候，发现其实是执行 runMicrotasks 😂。所以会把 Process.nextTick、Promise.then catch finally、MutationObserver 这些全部执行完毕后，才会进入下一步。

所以如果代码是这样的：

setImmediate(() => { console.log('setImmediate 1')})
process.nextTick(() => { console.log('nextTick 1') })
Promise.resolve().then(() => { console.log('promise then 1')})
process._tickCallback()
console.log('sync 1')

// result:
// nextTick 1
// promise then 1
// sync 1
// setImmediate 1

为什么会这样呢？因为 nextTicks 的名字有误，nodejs 网站上面有说， setImmediate 意思应该互换 nextTick。nextTick 才是在同一个阶段立即执行, 而 setImmediate 是在 EventLoop 接下来执行，或者在 tick 上触发。(文末参考链接)

使用例子

首先 deasync 库把 loopWhile 封装成一个等待方法：

function deasync(fn) {
    return function () {
        let done = false
        let args = Array.prototype.slice.apply(arguments).concat(cb)
        let err
        let res

        fn.apply(this, args)
        loopWhile(() => !done)
        if (err) throw err

        return res

        function cb(e, r) {
            err = e
            res = r
            done = true
        }
    }
}

然后可以写一个简单的阻塞 sleep 方法：

const sleep = deasync(function (timeout, done) {
    setTimeout(done, timeout)
})
sleep(1000) // 阻塞 1s
console.log('run here!')

更多可以去看看 deasync 中的例子。

un promisify

deasync 默认只处理带 callback 的方法。如果是想要处理 promise 的方法，需要包裹一层转化一下。

const unPromisify = fn => {
    return (...args) => {
        if (args.length<1) throw new Error('unPromisify arguments length must at least 2.')
        const cb = args.pop()
        fn(...args).then(data => cb(null, data)).catch(err => cb(err, null))
    }
}

async function say(e,e2) {
    console.log('good', e, e2)
    return 'r'
}

const saySync = deasync(unPromisify(say))
try {
    const c = saySync('allen', 'alex')
    console.log('return:', c)
} catch (e) {
    console.error(e)
}
console.log('done')

同样类型的库

还有一个类似功能的库：node-fibers，不过它的实现原理不同，并且复杂得多。

参考

• process.nextTick() 对比 setImmediate() 名称问题