1 概述

Nginx采用的是IO復用模型，能處理超高并發。
Go語言采用協程，能輕量級的處理超高并發。
那么在不考慮業務邏輯復雜的前提下，即假如將Nginx和Go都提供一個/test接口，并在接口邏輯中都只是讓其做20毫秒的耗時操作，那么這兩者的性能差異大概是多少呢？嘗試一下

2 環境說明

Centos 服務器環境說明：

3 源代碼

3.1 go

package mainimport ("net/http""time""log"
)func handler(w http.ResponseWriter, r *http.Request) {// 模擬 20ms 業務處理time.Sleep(20 * time.Millisecond)w.Write([]byte("OK"))
}func main() {http.HandleFunc("/test", handler)log.Println("Go server listening on :8080")if err := http.ListenAndServe(":8080", nil); err != nil {log.Fatal(err)}
}

3.2 nginx openresty

worker_processes  auto;
events {worker_connections 10240;
}http {# 如果你原來有其它配置項（如 log_format、lua_shared_dict 等），保留它們server {listen 8081;location = /test {content_by_lua_block {-- 模擬 20 ms 業務處理ngx.sleep(0.02)ngx.say("OK")}}}
}

4 啟動服務

go服務啟動端口為8080

nginx openresty 服務啟動端口為8081

5 ab工具壓測

5.1 第一輪：100并發共請求1萬次

go：
ab -n 10000 -c 100 http://127.0.0.1:8080/

Concurrency Level:      100
Time taken for tests:   2.134 seconds
Complete requests:      10000
Failed requests:        0
Write errors:           0
Non-2xx responses:      10000
Total transferred:      1760000 bytes
HTML transferred:       190000 bytes
Requests per second:    4685.38 [#/sec] (mean)
Time per request:       21.343 [ms] (mean)
Time per request:       0.213 [ms] (mean, across all concurrent requests)
Transfer rate:          805.30 [Kbytes/sec] received

nginx:

Concurrency Level:      100
Time taken for tests:   3.322 seconds
Complete requests:      10000
Failed requests:        0
Write errors:           0
Total transferred:      1288900000 bytes
HTML transferred:       1286460000 bytes
Requests per second:    3010.62 [#/sec] (mean)
Time per request:       33.216 [ms] (mean)
Time per request:       0.332 [ms] (mean, across all concurrent requests)
Transfer rate:          378944.26 [Kbytes/sec] received

小結：100并發情況下，go的QPS為4685，nginx的qps為3010

5.2 第二輪：500并發共請求5萬次

ab -n 50000 -c 500 http://127.0.0.1:8080/

go:

Concurrency Level:      500
Time taken for tests:   8.483 seconds
Complete requests:      50000
Failed requests:        0
Write errors:           0
Non-2xx responses:      50000
Total transferred:      8800000 bytes
HTML transferred:       950000 bytes
Requests per second:    5893.87 [#/sec] (mean)
Time per request:       84.834 [ms] (mean)
Time per request:       0.170 [ms] (mean, across all concurrent requests)
Transfer rate:          1013.01 [Kbytes/sec] received

nginx:

Concurrency Level:      500
Time taken for tests:   18.526 seconds
Complete requests:      50000
Failed requests:        0
Write errors:           0
Total transferred:      6444500000 bytes
HTML transferred:       6432300000 bytes
Requests per second:    2698.86 [#/sec] (mean)
Time per request:       185.264 [ms] (mean)
Time per request:       0.371 [ms] (mean, across all concurrent requests)
Transfer rate:          339702.78 [Kbytes/sec] received

奇怪，為什么500并發情況下，go的QPS有5893，而Nginx只有2698

5.3 第三輪：1000并發共請求10萬次

go:

Concurrency Level:      1000
Time taken for tests:   21.770 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Non-2xx responses:      100000
Total transferred:      17600000 bytes
HTML transferred:       1900000 bytes
Requests per second:    4593.43 [#/sec] (mean)
Time per request:       217.702 [ms] (mean)
Time per request:       0.218 [ms] (mean, across all concurrent requests)
Transfer rate:          789.50 [Kbytes/sec] received

nginx：

Concurrency Level:      1000
Time taken for tests:   39.272 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      12889000000 bytes
HTML transferred:       12864600000 bytes
Requests per second:    2546.37 [#/sec] (mean)
Time per request:       392.715 [ms] (mean)
Time per request:       0.393 [ms] (mean, across all concurrent requests)
Transfer rate:          320509.78 [Kbytes/sec] received

1000并發下，go的QPS有4593，nginx的QPS只有2546

6 小結

1.在如上配置的服務器環境+配置（注意：Nginx的配置應該可以一定程度上進行調優，這里暫時先不測試了）的情況下
2.go和nginx都提供一個/test的接口，且耗時都是在固定20秒的情況下
3.1000并發請求是，go的QPS為4.5k左右，nginx的QPS大概為2.5k左右。

7 臨時想到的Python和Java

7.1 Python3.6

既然看到了go語言的情況，自然又要拿出我們的老朋友python來測試一下了：

import asyncio
from aiohttp import webasync def handler(request):# 模擬 20 毫秒的耗時操作await asyncio.sleep(0.02)return web.Response(text="OK")app = web.Application()
app.router.add_get('/test', handler)if __name__ == '__main__':web.run_app(app, host='0.0.0.0', port=8080)

在經過了漫長的等待：故障了！

所以決定將并發控制在200，總請求數控制在20000

Concurrency Level:      200
Time taken for tests:   52.494 seconds
Complete requests:      20000
Failed requests:        0
Write errors:           0
Non-2xx responses:      20000
Total transferred:      3440000 bytes
HTML transferred:       280000 bytes
Requests per second:    381.00 [#/sec] (mean)
Time per request:       524.941 [ms] (mean)
Time per request:       2.625 [ms] (mean, across all concurrent requests)
Transfer rate:          64.00 [Kbytes/sec] received

從這里來看python3.6的QPS大概是381（注意！應該是有調優空間的，且每個接口中耗時20毫秒）

7.2 java1.8

import com.sun.net.httpserver.HttpServer;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpExchange;import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;public class SimpleHttpServer {public static void main(String[] args) throws IOException {// 創建 HTTP 服務器，監聽端口 8080HttpServer server = HttpServer.create(new InetSocketAddress(8080), 0);// 創建上下文，處理 /test 路徑的請求server.createContext("/test", new MyHandler());// 設置默認的執行器server.setExecutor(null);// 啟動服務器server.start();System.out.println("Java HTTP server started on port 8080");}static class MyHandler implements HttpHandler {@Overridepublic void handle(HttpExchange exchange) throws IOException {try {// 模擬 20 毫秒的耗時操作Thread.sleep(20);} catch (InterruptedException e) {e.printStackTrace();}String response = "OK";exchange.sendResponseHeaders(200, response.length());OutputStream os = exchange.getResponseBody();os.write(response.getBytes());os.close();}}
}

200并發2萬請求試試：3171

Concurrency Level:      200
Time taken for tests:   6.306 seconds
Complete requests:      20000
Failed requests:        0
Write errors:           0
Non-2xx responses:      20000
Total transferred:      2420000 bytes
HTML transferred:       1000000 bytes
Requests per second:    3171.68 [#/sec] (mean)
Time per request:       63.058 [ms] (mean)
Time per request:       0.315 [ms] (mean, across all concurrent requests)
Transfer rate:          374.78 [Kbytes/sec] received

1000并發10萬請求試試：5271

Concurrency Level:      1000
Time taken for tests:   18.969 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Non-2xx responses:      100000
Total transferred:      12100000 bytes
HTML transferred:       5000000 bytes
Requests per second:    5271.80 [#/sec] (mean)
Time per request:       189.688 [ms] (mean)
Time per request:       0.190 [ms] (mean, across all concurrent requests)
Transfer rate:          622.94 [Kbytes/sec] received

8 總結

1.go1.20 QPS 4.5k左右
2.nginx QPS 2.5k左右
3.python3.6 QPS 381左右
4.java1.8 QPS 5.2k左右

難不成是我測試的有問題？怎么java比go的QPS居然還要高？（有可能是調優問題+環境問題，go語言的性能可能在更高配置的環境下可能性能更高）該數據僅供參考