我們來(lái)看第二個(gè)讓 tj/co 崩潰的例子：

var co = require("co");

co(function*() {
    try {
        var a = [];
        for (i = 0; i < 1000000; i++) {
            a[i] = i;
        }
        var start = Date.now();;
        yield a;
        var end = Date.now();;
        console.log(end - start);
    }
    catch (e) {
        console.error(e);
    }
});

co(function*() {
    try {
        var a = [];
        a[0] = a;
        console.log(yield a);
    }
    catch (e) {
        console.error(e);
    }
});

co(function*() {
    try {
        var o = {};
        o.self = o;
        console.log(yield o);
    }
    catch (e) {
        console.error(e);
    }
});

運(yùn)行該程序，我們會(huì)看到程序會(huì)卡一會(huì)兒，然后出現(xiàn)下面的結(jié)果：

2530
(node:70754) UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 1): RangeError: Maximum call stack size exceeded
(node:70754) DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.
(node:70754) UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 2): RangeError: Maximum call stack size exceeded

上面的 2530 是第一個(gè) co 程序段輸出的結(jié)果，也就是說(shuō)這個(gè) yield 要等待 2.5 秒才能返回結(jié)果。而后面兩個(gè) co 程序段則直接調(diào)用棧溢出了。如果在實(shí)際應(yīng)用中，出現(xiàn)了這樣的數(shù)據(jù)，使用 tj/co 你的程序就會(huì)變得很慢，或者直接崩潰了。

下面看看 hprose.co 的效果，同樣只替換第一句話為：

var co = require("hprose").co;

后面的代碼都不需要修改，我們來(lái)看看運(yùn)行結(jié)果：

7
[ [Circular] ]
{ self: [Circular] }

第一個(gè) co 程序段用時(shí)很短，只需要 7 ms。注意，這還是包含了后面兩個(gè)程序段的時(shí)間，因?yàn)檫@三個(gè)協(xié)程是并發(fā)的，如果去掉后面兩個(gè)程序段，你看的輸出可能是 1 ms 或者 0 ms。而后面兩個(gè)程序段也完美的返回了帶有循環(huán)引用的數(shù)據(jù)。這才是我們期望的結(jié)果。

我們?cè)賮?lái)看看 async/await 下是什么效果，程序代碼如下：

(async function() {
    try {
        var a = [];
        for (i = 0; i < 1000000; i++) {
            a[i] = i;
        }
        var start = Date.now();
        await a;
        var end = Date.now();
        console.log(end - start);
    }
    catch (e) {
        console.error(e);
    }
})();

(async function() {
    try {
        var a = [];
        a[0] = a;
        console.log(await a);
    }
    catch (e) {
        console.error(e);
    }
})();

(async function() {
    try {
        var o = {};
        o.self = o;
        console.log(await o);
    }
    catch (e) {
        console.error(e);
    }
})();

運(yùn)行結(jié)果如下：

14
[ [Circular] ]
{ self: [Circular] }

我們發(fā)現(xiàn) async/await 的輸出結(jié)果跟 hprose.co 是一致的，但是在性能上，hprose.co 則比 async/await 還要快 1 倍。因此，第二個(gè)回合，hprose.co 仍然是完勝 tj/co 和 async/await。

我們?cè)賮?lái)看看 tj/co 和 tj/thunkify 是多么的讓人抓狂，以及 hprose.co 和 hprose.thunkify 是如何優(yōu)雅的解決 tj/co 和 tj/thunkify 帶來(lái)的這些讓人抓狂的問題的。

首先我們來(lái)看第一個(gè)問題：

tj/thunkify 返回的 thunk 函數(shù)的執(zhí)行結(jié)果是一次性的，不能像 promise 結(jié)果那樣被使用多次，我們來(lái)看看下面這個(gè)例子：

var co = require("co");
var thunkify = require("thunkify");

var sum = thunkify(function(a, b, callback) {
    callback(null, a + b);
});

co(function*() {
    var result = sum(1, 2);
    console.log(yield result);
    console.log(yield sum(2, 3));
    console.log(yield result);
});

這個(gè)例子很簡(jiǎn)單，輸出結(jié)果你猜是啥？

3
5
3

是上面的結(jié)果嗎？恭喜你，答錯(cuò)了！不過，這不是你的錯(cuò)，而是 tj/thunkify 的錯(cuò)，它的結(jié)果是：

3
5

什么？最后的 console.log(yield result) 輸出結(jié)果哪兒去了？不好意思，tj/thunkify 解釋說(shuō)是為了防止 callback 被重復(fù)執(zhí)行，所以就只能這么玩了。可是真的是這樣嗎？

我們來(lái)看看使用 hprose.co 和 hprose.thunkify 的執(zhí)行結(jié)果吧，把開頭兩行換成下面三行：

var hprose = require("hprose");
var co = hprose.co;
var thunkify = hprose.thunkify;

其它代碼都不用改，運(yùn)行它，你會(huì)發(fā)現(xiàn)預(yù)期的結(jié)果出來(lái)了，就是：

3
5
3

可能你還不服氣，你會(huì)說(shuō)，tj/thunkify 這樣做是為了防止類似被 thunkify 的函數(shù)中，回調(diào)被多次調(diào)用時(shí)，yield 的結(jié)果不正確，比如：

var sum = thunkify(function(a, b, callback) {
    callback(null, a + b);
    callback(null, a + b + a);
});

co(function*() {
    var result = sum(1, 2);
    console.log(yield result);
    console.log(yield sum(2, 3));
    console.log(yield result);
});

如果 tj/thunkify 不這樣做，結(jié)果可能就會(huì)變成：

3
4
5

可是真的是這樣嗎？你會(huì)發(fā)現(xiàn)，即使改成上面的樣子，hprose.thunkify 配合 hprose.co 返回的結(jié)果仍然是：

3
5
3

跟預(yù)期的一樣，回調(diào)函數(shù)并沒有重復(fù)執(zhí)行，錯(cuò)誤的結(jié)果并沒有出現(xiàn)。而且當(dāng)需要重復(fù) yield 結(jié)果函數(shù)時(shí)，還能夠正確得到結(jié)果。

最后我們?cè)賮?lái)看一下，tj/thunkify 這樣做真的解決了問題了嗎？我們把代碼改成下面這樣：

var sum = thunkify(function(a, b, callback) {
    console.log("call sum(" + Array.prototype.join.call(arguments) + ")");
    callback(null, a + b);
    callback(null, a + b + a);
});

co(function*() {
    var result = sum(1, 2);
    console.log(yield result);
    console.log(yield sum(2, 3));
    console.log(yield result);
});

然后替換不同的 co 和 thunkify，然后執(zhí)行，我們會(huì)發(fā)現(xiàn)，tj 版本的輸出如下：

call sum(1,2,function (){
        if (called) return;
        called = true;
        done.apply(null, arguments);
      })
3
call sum(2,3,function (){
        if (called) return;
        called = true;
        done.apply(null, arguments);
      })
5
call sum(1,2,function (){
        if (called) return;
        called = true;
        done.apply(null, arguments);
      },function (){
        if (called) return;
        called = true;
        done.apply(null, arguments);
      })

而 hprose 版本的輸出結(jié)果如下：

call sum(1,2,function () {
                thisArg = this;
                results.resolve(arguments);
            })
3
call sum(2,3,function () {
                thisArg = this;
                results.resolve(arguments);
            })
5
3

從這里，我們可以看出，tj 版本的程序在執(zhí)行第二次 yield result 時(shí)，簡(jiǎn)直錯(cuò)的離譜，它不但沒有讓我們得到預(yù)期的結(jié)果，反而還重復(fù)執(zhí)行了 thunkify 后的函數(shù)，而且?guī)氲膮?shù)也完全不對(duì)了，所以，這是一個(gè)完全錯(cuò)誤的實(shí)現(xiàn)。

而從 hprose 版本的輸出來(lái)看，hprose 不但完美的避免了回調(diào)被重復(fù)執(zhí)行，而且保證了被 thunkify 后的函數(shù)執(zhí)行的結(jié)果被多次 yield 時(shí)，也不會(huì)被重復(fù)執(zhí)行，而且還能夠得到預(yù)期的結(jié)果，可以實(shí)現(xiàn)跟返回 promise 對(duì)象一樣的效果。

tj 因?yàn)闆]有解決他所實(shí)現(xiàn)的 thunkify 函數(shù)帶來(lái)的這些問題，所以在后期推薦大家放棄 thunkify，轉(zhuǎn)而投奔到返回 promise 對(duì)象的懷抱中，而實(shí)際上，這個(gè)問題并非是不能解決的。

hprose 在對(duì) thunkify 函數(shù)的處理上，再次完勝 tj。而這個(gè)回合中，async/await 就不用提了，因?yàn)?async/await 完全不支持對(duì) thunk 函數(shù)進(jìn)行 await。

這還不是 hprose.co 和 hprose.thunkify 的全部呢，再繼續(xù)看下面這個(gè)例子：

var sum = thunkify(function(a, b, callback) {
    callback(a + b);
});

co(function*() {
    var result = sum(1, 2);
    console.log(yield result);
    console.log(yield sum(2, 3));
    console.log(yield result);
});

這里開頭對(duì) hprose 和 tj 版本的不同 co 和 thunkify 實(shí)現(xiàn)的引用就省略了，請(qǐng)大家自行腦補(bǔ)。

上面這段程序，如果使用 tj 版本的 co 和 thunkify 實(shí)現(xiàn)，運(yùn)行結(jié)果是這樣的：

(node:75927) UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 2): 3
(node:75927) DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.

而如果使用 hprose 版本的 co 和 thunkify 實(shí)現(xiàn)，運(yùn)行結(jié)果是這樣的：

3
5
3

hprose 版本的運(yùn)行結(jié)果再次符合預(yù)期，而 tj 版本的運(yùn)行結(jié)果再次讓人失望之極。

進(jìn)過上面三個(gè)回合的較量，我們發(fā)現(xiàn) hprose 的協(xié)程完勝 tj 和 async/await，而且 tj 的實(shí)現(xiàn)是慘敗，async/await 雖然比 tj 稍微好那么一點(diǎn)，但是跟 hprose 所實(shí)現(xiàn)協(xié)程比起來(lái)，也是望塵莫及。

所以，用 tj/co 和 async/await 感覺很不爽的同學(xué)，可以試試 hprose.co 了，絕對(duì)讓你爽歪歪。

hprose 有 4 個(gè) JavaScript 版本，它們都支持上面的協(xié)程庫(kù)，它們的地址分別是：

hprose for Node.js(oschina鏡像)

hprose for HTML5(oschina鏡像)

hprose for JavaScript(oschina鏡像)

hprose for 微信小程序(oschina鏡像)

另外，如果你不需要使用 hprose 序列化和遠(yuǎn)程調(diào)用的話，下面還有一個(gè)專門的從 hprose 中精簡(jiǎn)出來(lái)的 Promise A+ 實(shí)現(xiàn)和協(xié)程庫(kù)：Future.js(oschina鏡像)

當(dāng)然該協(xié)程庫(kù)的功能不止于此，更多介紹請(qǐng)參見：

Promise 異步編程

協(xié)程