golang與node.js的http模塊性能對比測試（go1）

去年的時候，曾經簡單對比了一下golang和nodejs的http模塊的性能，見： golang與node.js的http對比測試

那時golang還沒發布go1，http模塊比nodejs差得很遠。

go1出來已經有一段時間了，我知道go的http模塊性能已經有比較大的提升，但是最近依然見到有人提起去年寫的那篇文章，為避免產生對golang的誤解，對於go1的最新測試結果如下。

測試是在Ubuntu 12.04 64位系統下進行的：

qleelulu@nb:~$ uname -a
Linux nb 3.2.0-25-generic #40-Ubuntu SMP Wed May 23 20:30:51 UTC 2012 x86_64 x86_64 x86_64 GNU/Linux

qleelulu@nb:~$ sudo dmidecode | grep CPU
Socket Designation: CPU
Version: Intel(R) Core(TM) i5 CPU M 480 @ 2.67GHz (注：雙核4線程)

 

go的版本：

qleelulu@nb:~$ go version
go version go1

 

nodejs的版本：

qleelulu@nb:~$ node -v
v0.8.6

 

單CPU測試

nodejs是單進程，只使用一個CPU，所以這里golang在代碼中需要限制為只使用一個CPU。

go的代碼： （注：go代碼都是使用 go build xxx.go 編譯）

package main

import (
    "fmt"
    "log"
    "net/http"
    "runtime"
)

func main() {
    // 限制為1個CPU
    runtime.GOMAXPROCS(1)

    http.HandleFunc("/", func(w http.ResponseWriter, r  *http.Request) {
        fmt.Fprint(w, "Hello, world.")
    })

    log.Fatal(http.ListenAndServe(":8080", nil))
}

 

golang請求結果：

qleelulu@nb:~/sources/test$ curl -i http://127.0.0.1:8080/
HTTP/1.1 200 OK
Date: Sun, 12 Aug 2012 07:21:00 GMT
Transfer-Encoding: chunked
Content-Type: text/plain; charset=utf-8

Hello, world.

 

golang單cpu的ab測試結果：

qleelulu@nb:~$ ab -c 100 -n 5000 http://127.0.0.1:8080/
This is ApacheBench, Version 2.3 <$Revision: 655654 $>

Server Software: 

Server Hostname: 127.0.0.1
Server Port: 8080

Document Path: /
Document Length: 13 bytes

Concurrency Level: 100
Time taken for tests: 0.593 seconds
Complete requests: 5000
Failed requests: 0
Write errors: 0
Total transferred: 550000 bytes
HTML transferred: 65000 bytes
Requests per second: 8427.78 [#/sec] (mean)
Time per request: 11.866 [ms] (mean)
Time per request: 0.119 [ms] (mean, across all concurrent requests)
Transfer rate: 905.33 [Kbytes/sec] received
...

 

共測試五次，五次結果分別如下：

Requests per second:    8427.78 [#/sec] (mean)
Requests per second:    7980.73 [#/sec] (mean)
Requests per second:    7509.63 [#/sec] (mean)
Requests per second:    8242.47 [#/sec] (mean)
Requests per second:    8898.19 [#/sec] (mean)

golang單cpu的webbench測試結果：

qleelulu@nb:~$ webbench -t 30 -c 200 http://127.0.0.1:8080/
Webbench - Simple Web Benchmark 1.5
Copyright (c) Radim Kolar 1997-2004, GPL Open Source Software.

Benchmarking: GET http://127.0.0.1:8080/
200 clients, running 30 sec.

Speed=463124 pages/min, 849060 bytes/sec.
Requests: 231562 susceed, 0 failed.

 

共測試五次，結果如下：

Speed=463124 pages/min, 849060 bytes/sec.
Speed=455322 pages/min, 834757 bytes/sec.
Speed=461536 pages/min, 846149 bytes/sec.
Speed=454798 pages/min, 833803 bytes/sec.
Speed=468592 pages/min, 859085 bytes/sec.

golang單CPU webbench測試時，CPU使用率如下：

 

nodejs 單CPU測試代碼：

var http = require('http');
http.createServer(function (req, res) {
    res.end('Hello, World.');
}).listen(8080, '127.0.0.1');
console.log('Server running at http://127.0.0.1:8080/');

 

nodejs請求結果：

qleelulu@nb:~/$ curl -i http://127.0.0.1:8080/
HTTP/1.1 200 OK
Date: Sun, 12 Aug 2012 07:45:23 GMT
Connection: keep-alive
Transfer-Encoding: chunked

Hello, World.

為方便對比golang的返回結果，再貼一次golang的返回結果：

golang請求結果：
qleelulu@nb:~/sources/test$ curl -i http://127.0.0.1:8080/
HTTP/1.1 200 OK
Date: Sun, 12 Aug 2012 07:21:00 GMT
Transfer-Encoding: chunked
Content-Type: text/plain; charset=utf-8

Hello, world.

 

nodejs的單cpu ab測試結果：

qleelulu@nb:~$ ab -c 100 -n 5000 http://127.0.0.1:8080/
This is ApacheBench, Version 2.3 <$Revision: 655654 $>

Server Software: 
Server Hostname: 127.0.0.1
Server Port: 8080

Document Path: /
Document Length: 13 bytes

Concurrency Level: 100
Time taken for tests: 0.696 seconds
Complete requests: 5000
Failed requests: 0
Write errors: 0
Total transferred: 440000 bytes
HTML transferred: 65000 bytes
Requests per second: 7185.91 [#/sec] (mean)
Time per request: 13.916 [ms] (mean)
Time per request: 0.139 [ms] (mean, across all concurrent requests)
Transfer rate: 617.54 [Kbytes/sec] received

 

共測試5次，結果如下

Requests per second:    7185.91 [#/sec] (mean)
Requests per second:    7484.97 [#/sec] (mean)
Requests per second:    7388.25 [#/sec] (mean)
Requests per second:    7411.80 [#/sec] (mean)
Requests per second:    7571.10 [#/sec] (mean) 

nodejs單cpu的webbench測試結果：

qleelulu@nb:~$ webbench -t 30 -c 200 http://127.0.0.1:8080/
Webbench - Simple Web Benchmark 1.5
Copyright (c) Radim Kolar 1997-2004, GPL Open Source Software.

Benchmarking: GET http://127.0.0.1:8080/
200 clients, running 30 sec.

Speed=432582 pages/min, 634453 bytes/sec.
Requests: 216291 susceed, 0 failed.

 

共測試5次，結果如下

Speed=432582 pages/min, 634453 bytes/sec.
Speed=434868 pages/min, 637803 bytes/sec.
Speed=435608 pages/min, 638891 bytes/sec.
Speed=434466 pages/min, 637216 bytes/sec.
Speed=431816 pages/min, 633330 bytes/sec. 

nodejs單CPU webbench測試時，CPU使用率如下：

 

單CPU測試go和nodes的ab測試對比結果：

從單CPU的測試結果來看，golang和nodejs的性能差不多，golang要稍微比nodejs的性能好一點。
但是從CPU的使用率來看，特別是在webbench測試的時候，測golang的時候，我筆記本上4個CPU的使用率都在50%左右，而測nodejs的時候，則明顯是有一個CPU的使用率是在100%，其他的在30%左右。 
對於nodejs， 一個CPU占用去到100%是很正常的，V8引擎也從來都是非常吃CPU的。對於golang為什么限制為僅使用1個CPU，而測試時4個CPU的使用率都去到50%，可能和go對於goroutine的調度方式有關系。

 

多CPU測試

go測試代碼：
因為是在同一台機器上測試的，所以限制使用的CPU數為機器的CPU數減一。

package main

import (
    "fmt"
    "log"
    "net/http"
    "runtime"
)

func main() {
    // 限制為CPU的數量減一
    runtime.GOMAXPROCS( runtime.NumCPU() - 1 )

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "Hello, world.")
    })

    log.Fatal(http.ListenAndServe(":8080", nil))
}

 

golang的多CPU ab測試結果，共測試5次，結果如下：

$ ab -c 100 -n 5000 http://127.0.0.1:8080/

Requests per second:    14391.80 [#/sec] (mean)
Requests per second:    14307.09 [#/sec] (mean)
Requests per second:    14285.31 [#/sec] (mean)
Requests per second:    15182.34 [#/sec] (mean)
Requests per second:    14020.53 [#/sec] (mean)

 

golang的多CPU webbench測試結果，共測試5次，結果如下： 

$ webbench -t 30 -c 200 http://127.0.0.1:8080/

Speed=750418 pages/min, 1375982 bytes/sec.
Speed=750492 pages/min, 1375909 bytes/sec.
Speed=749128 pages/min, 1373408 bytes/sec.
Speed=749720 pages/min, 1374486 bytes/sec.
Speed=753080 pages/min, 1380698 bytes/sec. 

 

golang多CPU webbench測試時，CPU使用率如下：

 

nodejs測試代碼
使用cluster，使用CPU數量減一個CPU

var cluster = require('cluster');
var http = require('http');
var numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
    // Fork workers. fock num of CPUS - 1 works
    for (var i = 1; i < numCPUs; i++) {
        cluster.fork();
    }

    cluster.on('exit', function(worker, code, signal) {
        console.log('worker ' + worker.process.pid + ' died');
    }); 
    cluster.on('fork', function(worker, code, signal) {
        console.log('worker ' + worker.process.pid + ' is online');
    }); 
} else {
    // Workers can share any TCP connection
    // In this case its a HTTP server
    http.createServer(function(req, res) {
        res.writeHead(200);
        res.end("hello world.");
    }).listen(8080);
}

 

 

nodejs的多CPU ab測試結果，共測試5次，結果如下：

$ ab -c 100 -n 5000 http://127.0.0.1:8080/

Requests per second:    12694.96 [#/sec] (mean)
Requests per second:    12606.68 [#/sec] (mean)
Requests per second:    12712.68 [#/sec] (mean)
Requests per second:    12851.16 [#/sec] (mean)
Requests per second:    13005.08 [#/sec] (mean) 

 

nodejs的多CPU webbench測試結果，共測試5次，結果如下： 

$ webbench -t 30 -c 200 http://127.0.0.1:8080/

Speed=791932 pages/min, 1148301 bytes/sec.
Speed=786516 pages/min, 1140448 bytes/sec. 
Speed=797336 pages/min, 1156140 bytes/sec.
Speed=783182 pages/min, 1135619 bytes/sec.
Speed=785206 pages/min, 1138551 bytes/sec. 

 

nodejs多CPU webbench測試時，CPU使用率如下：

 

多CPU測試結果來看，總體上來說go和nodejs的性能也還是差不多。
但從ab測試的結果來看，go的QPS要比nodejs高一點，
而從webbench測試結果來看，nodejs的QPS要比go高，但是go的bytes/sec又要比nodes高，可能是go的http返回頭比nodes要稍微大一點的原因。

多CPU測試時的CPU使用情況和單cpu測試時的情況差不多，
golang對4個cpu的占用率都在70%左右，
而node則是對3個CPU的占用在90%以上，還有一個CPU的占用率則要稍微低點。 

 

從整體來看，golang和nodejs的http模塊性能不相上下。
go1的性能還是比較喜人的，加上go語音的簡潔，是個不錯的選擇（目前可能go的一些第三方模塊都不是很成熟）。