• 首页
  • nodejs
  • async和eventproxy在流程控制上哪个更优秀

async和eventproxy在流程控制上哪个更优秀


由于node.js特性异步IO,导致 node.js 开发常常让你头疼的是异步嵌套回调.

一层一层的大括号嵌套让你当场就迷失在回调函数中,更不用说隔一段时间自己去维护这段代码的时候,恨不能砸显示器来泄愤.

不过这个世界还是美好的,你遇到的问题大家也都遇到了,而且大牛们致力于减轻码农的各种node.js 的痛苦,开发出了高效好用的流程控制包,让你的逻辑变的清晰,维护起来一目了然.

常用的有 async ,step ,eventproxy

step本人接触很少,一直在用async,也是最近注意到了 eventproxy ,我想看看哪个性能更优,代码更加优雅,所以有了下面一个小demo.


这个demo不去比较实现原理,内部代码,而仅仅是从使用的角度,看一下在多个逻辑嵌套的情况下哪个速度稍微快一点,不太感兴趣的可以直接忽略下面内容.


首先需要引入 async 和 eventproxy npm包.

npm install async eventproxy


var EventProxy = require('eventproxy');

var async = require('async');


为了排除外界的干扰,我的逻辑测试代码没有涉及到网络请求,没有数据库,文件io处理,仅仅是一个消耗cpu的数学计算,我选择了 斐波纳契数列之和,很简单的数列,不明白的可以问度娘.

斐波纳契数列是这样的数列:1、1、2、3、5、8、13、21、……

数学模型上的实现方法是这样:F0=0,F1=1,Fn=F(n-1)+F(n-2)(n>=2)

数列的每个值是前面2个值的和.现在我们要求一个数值对应的斐波纳契数列之和,如果数值足够大,这个程序的递归迭代还是很耗cpu的.

代码实现如下:


function step1(n) {

if (n > 2)

return step1(n - 1) + step1(n - 2);

else

return 1;

}


在流程控制过程中,求一个数值的斐波纳契数列之和就表示一个业务逻辑处理,所以为了模拟一系列逻辑处理节点.

我需要给多个数值求斐波纳契数列,所以干脆我定义一个数组.

var len,val = [],

arr = [36, 39, 38, 31, 36,37,29,24,28,37,35,33,38,35,37];

len在后面会保存arr数组长度,val数组用来存放元素 斐波那契数列之和 .

上面的15个数字代表15次逻辑处理.


(一)用数组for循环15次逻辑处理,然后用计数器自动记录处理次数.最后返回保存斐波那契数列和的数组 val.


//for

console.time('for_time');

len = arr.length;

val = [];

console.log('------for循环测试开始------')


for (var i = 0; i < arr.length; i++) {

val.push(step1(arr[i]));


if (--len == 0) {

console.log(val);

console.timeEnd('for_time');

}

}



(二)async 用series串行无关联 和 parallel并行无关联 测试

async下的each /forEach 我随便测试了一下,下面主要看2种流程控制


//async  串行无关联

console.time('async_Series');

val = [];

console.log('------async_Series 测试开始------')

async.series([

  function(done){ 

      //逻辑处理

      done(null,val.push(step1(arr[0])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[1])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[2])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[3])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[4])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[5])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[6])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[7])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[8])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[9])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[10])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[11])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[12])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[13])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[14])));

  }

],function(error,result){

    //最后结果

  console.log(val);

console.timeEnd('async_Series');

});



//async 并行无关联

console.time('async_parallel');

val = [];

console.log('------async_parallel 测试开始------')

async.parallel([

  function(done){ 

      //逻辑处理

      done(null,val.push(step1(arr[0])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[1])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[2])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[3])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[4])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[5])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[6])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[7])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[8])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[9])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[10])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[11])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[12])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[13])));

  },

  function(done){

      //逻辑处理

      done(null,val.push(step1(arr[14])));

  }

],function(error,result){

    console.log(val);

console.timeEnd('async_parallel');

});


(三)eventproxy 实现流程控制

flag1 到 flag15 手动输入好烦,有没有简单好用的方法.


//eventproxy

console.time('eventproxy');

val = [];

console.log('------eventproxy 测试开始------');

var ep = EventProxy.create("flag1", "flag2", "flag3","flag4","flag5","flag6", "flag7", "flag8","flag9","flag10","flag11", "flag12", "flag13","flag14","flag15",function (flag1, flag2,flag3,flag4,flag5,flag6, flag7,flag8,flag9,flag10,flag11, flag12,flag13,flag14,flag15) {

console.log(val);

console.timeEnd('eventproxy');

});



  ep.emit("flag1", val.push(step1(arr[0])));


  ep.emit("flag2", val.push(step1(arr[1])));


  ep.emit("flag3", val.push(step1(arr[2])));


  ep.emit("flag4", val.push(step1(arr[3])));


  ep.emit("flag5", val.push(step1(arr[4])));


  ep.emit("flag6", val.push(step1(arr[5])));


  ep.emit("flag7", val.push(step1(arr[6])));


  ep.emit("flag8", val.push(step1(arr[7])));


  ep.emit("flag9", val.push(step1(arr[8])));


  ep.emit("flag10", val.push(step1(arr[9])));


  ep.emit("flag11", val.push(step1(arr[10])));


  ep.emit("flag12", val.push(step1(arr[11])));


  ep.emit("flag13", val.push(step1(arr[12])));


  ep.emit("flag14", val.push(step1(arr[13])));


  ep.emit("flag15", val.push(step1(arr[14])));

  

  三种测试方法代码已经完成,下面就运行一下:


上面这一组测试结果很难看出问题,如果你把代码自己运行一下,你会看到所耗时间数据是很跳跃的,尤其像上面 async 的并行方法速度竟然比串行方法速度慢了一大截,一下感觉这个世界也不美好了.(上面的测试结果包含了async 的each 等运行结果,但是上面代码我去掉了这部分)

大概是因为这个密集型cpu运算,导致每个流程把cpu资源都消耗在了斐波那契数列之和的计算上,而真正逻辑处理的时候,由于逻辑处理也就15个,在cpu被计算全部占用后,流程控制上几乎无法比较了.所以这个结果很不稳定,一会eventproxy优于async ,一会又相反的结果.

所以打算让逻辑处理简单一点,不要把cpu压力全部集中在计算上,而让资源也充分体现在流程控制上.于是把上面的15个元素的数组改成了下面这样.

arr = [6, 13, 8, 10, 6,7,9,4,8,14,15,16,6,7,9];

还是15个,但是明显数值都很低.

然会进行下一轮测试:

虽然这么小的样本是无法说明一个结果的,但是在这个不靠谱的测试结果中,我们貌似看到了自己用for循环+计数器控制流程明显是耗时多一点. eventproxy 表现稳定,在这个测试表现最优,async表现有点不稳定 paraller 在 series名下没有表现出并行的优势.有待于更深层次的比较和一个大而全的样本来说服,这次的小测试就看做是一个熟悉代码的学习吧.



回到顶部