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

时间  2020-07-26 标签 node.js node js 性能 初 窥 计算 性能 qt c++ golang node.js node js

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


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

测试硬件平台以下:golang

电脑型号 苹果 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.21app

Qt5.2 beta1ide

Golang 1.2 R3性能


测试方法:测试

每一趟计算斐波那契8次.总共10趟（一共80次）计算总时间.ui

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

[javascript]  view plain copy print ?
  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 plain copy print ?
  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++)中作一样的处理(多线程)

[cpp]  view plain copy print ?
  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单线程代码以下:

[plain]  view plain copy print ?
  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线程计算:

[cpp]  view plain copy print ?
  1. package main  
  2.   
  3. import (  
  4.     "fmt"  
  5.     "time"  
  6.     "runtime"  
  7. )  
  8.   
  9. func fibonacci(num int) int {  
  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核服务器上再跑一次看看结果怎么样.

联系我们 沪ICP备2021010478号-7