Node.js性能初窥-计算性能(Qt/C++,Golang,Node.js)

mywcyfl · · 6645 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

原文地址:http://blog.csdn.net/slug302/article/details/14521261


大家都知道Node.js的单进程非阻塞模型适合于任务密集性(I/O)而不是计算密集型.那么到底有多不适合计算呢?下面做一个简单的测试.

测试硬件平台如下:

电脑型号 苹果 Macmini6,2 Lunch Box
操作系统 Windows 8 Enterprise 64位 ( DirectX 11 )
处理器         英特尔 第三代酷睿 i7-3615QM @ 2.30GHz 四核
内存         16 GB ( 三星 DDR3 1600MHz )
主硬盘         APPLE HDD HTS541010A9E662 ( 1 TB )


软件平台:

Node.js 0.10.21

Qt5.2 beta1

Golang 1.2 R3


测试方法:

每一趟计算斐波那契8次.总共10趟(一共80次)计算总时间.

Node.js 不使用cluster模块.测试代码如下:

[javascript] view plaincopyprint?
  1. function fibo (n) {  
  2.     return n > 1 ? fibo(n - 1) + fibo(n - 2) : 1;  
  3. }  
  4. var n = 8;  
  5. function back(){  
  6.     if(!--n) {  
  7.         return console.timeEnd('total time');  
  8.     }  
  9. }  
  10.   
  11. console.time('<span style="font-family:Arial,Helvetica,sans-serif">total time</span>');  
  12.   
  13. for(var i = 0; i < 8; ++i){  
  14.     process.nextTick(function(){  
  15.         console.log(fibo (40));  
  16.         back();  
  17.     });  
  18. }  
10次总时间132393ms


.....额有人会说有cluster模块可以以多个进程的方式处理,效率会提升.那我们来看看使用cluster之后的效果如何

[javascript] view plaincopyprint?
  1. //cluster  
  2. var cluster = require('cluster');  
  3. var numCPUs = 8;    //我的cpu是四核八线程  
  4. function fibo (n) {  
  5.     return n > 1 ? fibo(n - 1) + fibo(n - 2) : 1;  
  6. }  
  7. console.time('8 cluster');  
  8. if (cluster.isMaster) {  
  9.     // Fork workers.  
  10.     for (var i = 0; i < numCPUs; i++) {  
  11.         cluster.fork();  
  12.     }  
  13.     var i = 8;  
  14.     cluster.on('exit'function(worker, code, signal) {  
  15.         if(!--i){  
  16.             console.timeEnd('8 cluster');  
  17.             process.exit(0);  
  18.         }  
  19.     });  
  20. else {  
  21.     console.log(fibo (40));  
  22.     process.exit(0);  
  23. }  

10次总时间30322ms


下面是Qt(C++)中做同样的处理(多线程)

  1. #include <QThread>  
  2. #include <QDebug>  
  3. #include <QTime>  
  4. #include <QtConcurrent>  
  5.   
  6. int fibo(int n)  
  7. {  
  8.     return n > 1? fibo(n-1) + fibo(n-2):1;  
  9. }  
  10.   
  11. int main(int argc, char *argv[])  
  12. {  
  13.     QList<int> lists;  
  14.     for (int i = 0; i < 8; ++i)  
  15.     {  
  16.         lists.append(40);  
  17.     }  
  18.   
  19.     QTime start;  
  20.     start.start();  
  21.   
  22.     QList<int> thumbnails = QtConcurrent::blockingMapped(lists, fibo);  
  23.     foreach (int i, thumbnails)  
  24.     {  
  25.         qDebug() << i;  
  26.     }  
  27.     qDebug() <<"total time is :  "<< start.elapsed();  
  28. }  
Debug编译10次总时间14279ms

Release编译10次总时间8280ms


还有一个单线程的也是做同样的计算,代码就不贴了只贴结果

Debug编译10次总时间64864ms

Release编译10次总时间37790ms


Golang单线程代码如下:

  1. package main  
  2.   
  3. import (  
  4.     "fmt"  
  5.     "time"  
  6. )  
  7.   
  8. func fibonacci(num int) int {  
  9.     if num < 2 {  
  10.         return 1  
  11.     }  
  12.     return fibonacci(num-1) + fibonacci(num-2) //我不记得golang有没有三目运算符了......  
  13. }  
  14.   
  15. func main() {  
  16.   
  17.     start := time.Now()  
  18.   
  19.     for i := 0; i < 8; i++ {  
  20.         nums := fibonacci(40)  
  21.         fmt.Println(nums)  
  22.     }  
  23.   
  24.     end := time.Now()  
  25.   
  26.     fmt.Println("total time:", end.Sub(start).Nanoseconds()/1000/1000)  
  27. }  
十次总时间73910ms.


Golang 使用8线程计算:

  1. package main  
  2.   
  3. import (  
  4.     "fmt"  
  5.     "time"  
  6.     "runtime"  
  7. )  
  8.   
  9. func fibonacci(num intint {  
  10.     if num < 2 {  
  11.         return 1  
  12.     }  
  13.     return fibonacci(num-1) + fibonacci(num-2) //我不记得golang有没有三目运算符了......  
  14. }  
  15.   
  16. func main() {  
  17.   
  18.     ch := make(chan int, 8)  
  19.     runtime.GOMAXPROCS(8)  
  20.   
  21.     start := time.Now()  
  22.   
  23.     for i := 0; i < 8; i++ {  
  24.         go func(){  
  25.             nums := fibonacci(40)  
  26.             ch <- nums  
  27.         } ()  
  28.         //fmt.Println(nums)  
  29.     }  
  30.   
  31.     for i := 0; i < 8; i++{  
  32.         fmt.Println(<-ch)  
  33.     }  
  34.   
  35.     end := time.Now()  
  36.   
  37.     fmt.Println("total time:", end.Sub(start).Nanoseconds()/1000/1000)  
  38. }  
10次总时间14780ms

详细测试结果如下:

无cluster 8cluster 8线程Debug 8线程Release 单线程Debug 单线程Release Golang单线程 Golang 8线程
13212 3031 1502 847 6538 3804 7413 1443
13253 3029 1429 841 6473 3768 7371 1420
13233 3014 1429 810 6488 3812 7380 1442
13232 3044 1414 811 6467 3757 7420 1545
13465 2980 1466 818 6477 3782 7387 1507
13244 3018 1414 805 6504 3758 7377 1465
13213 3061 1414 831 6461 3771 7373 1494
13192 3025 1402 857 6512 3816 7391 1463
13143 3075 1398 801 6476 3747 7402 1503
13206 3045 1411 859 6468 3775 7396 1498
132393 30322 14279 8280 64864 37790 73910 14780



看数据不太直观那看看下面的图吧......


总结:

我们可以看到在计算性能上C++ > Golang > Node.js. 

C++单核和多线程效率都差不多是Golang一倍

Golang单核和多线程性能差不多是Node.js的一倍


写在最后:

本次并非全面的权威的测试,测试结果仅仅作为一方面的参考,并不能说明Node.js效率就是渣渣.而且Node.js我也是初学,代码也有可能有误.对于测试结果大家不要太过于介怀,仁者见仁智者见智.


回去了在我的24核服务器上再跑一次看看结果怎么样.


有疑问加站长微信联系(非本文作者)

本文来自:CSDN博客

感谢作者:mywcyfl

查看原文:Node.js性能初窥-计算性能(Qt/C++,Golang,Node.js)

入群交流(和以上内容无关):加入Go大咖交流群,或添加微信:liuxiaoyan-s 备注:入群;或加QQ群:692541889

6645 次点击  
加入收藏 微博
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传