大家好,我是 世奇,笔名 ConardLi

今天我们来看个有意思的话题,在 Node.js 中引入 Golang ,会让服务更快吗?

我们都知道,Nodejs 适合 I/O 密集型任务,但不适合 CPU 密集型任务。同时,我们有很多方式来处理此类任务(子进程/集群、工作线程)。此外,还有可能使用其他语言(C、C++、Rust、Golang)作为单独的服务/微服务或通过 WebAssembly 脚本进行调用。

这篇文章并不是一个 Node.jsGolang 的语言对比,而是在 Node.js 开发服务的角度,尝试在某些场景下引入 Golang(让它去执行一些 CPU 密集型操作),看看会不会更快。

之前我也写过一篇,在 React 项目中引入 Rust 的文章,感兴趣可以看:使用 Rust 编写更快的 React 组件

最近发现了一个老外做了在 Node.js 服务中引入 Golang 的性能测试(https://blog.devgenius.io/node-js-in-go-we-trust-7da6395776f2),挺有意思的,遂翻译了一下。

测试项

    1. 尝试仅使用 Node.js 解决 CPU 密集型任务
    1. 创建单独使用 的Golang 编写的服务,并通过发送请求或消息队列的方式将其连接到应用里面
    1. 使用 Golang 构建 wasm 文件以运行 Node.js 中的某些方法

速度与金钱

我是老式意大利西部片的粉丝,尤其是《The Good, the Bad and the Ugly》。我们在本文中我们有 3 个测试项,对应电影中的 3 个英雄。

Node.js(好人)

优点:

    1. 前后端使用相同的语言
    1. I/O 操作大师 - 超快的事件循环
    1. 最大的武器库 - npm

Golang(坏人)

优点:

    1. Google 设计
    1. 几乎所有操作系统都支持
    1. “Goroutines” - Golang 中的特殊函数,可以与其他函数或方法同时运行(适用于 CPU 密集型任务)
    1. 简单 - 只有 25 个关键词

nodejs-golang/WebAssembly(丑陋的人)

优点:

    1. 随处可用
    1. 补充 JavaScript
    1. 可以用不同的语言编写代码并在 JavaScript 中使用 .wasm 脚本

最后这个测试项我们重点聊聊:

通过将操作系统设置为 “js” 并将架构设置为 “wasm”``(所有的 GOOSGOARCH` 值列表在这里 https://go.dev/doc/install/source#environment ),可以将 Golang 代码构建为 .wasm 文件:

1
GOOS=js GOARCH=wasm go build -o main.wasm

要运行编译后的 Go 代码,你需要 wasm_exec.js 中的 glue code 。它在这里找到:

1
${GOROOT}/misc/wasm/wasm_exec.js

为了实例化,我使用了 @assemblyscript/loader 并创建了一个 nodejs-golang 模块(顺便说一句,@assemblyscript/loader 是它的唯一依赖项)。这个模块有助于创建、构建和运行可在 JavaScript 代码中使用的单独的 wasm 脚本或函数

1
2
3
4
5
6
require('./go/misc/wasm/wasm_exec');
const go = new Go();
...
const wasm = fs.readFileSync(wasmPath);
const wasmModule = await loader.instantiateStreaming(wasm, go.importObject);
go.run(wasmModule.instance);

顺便说一句,其他语言可以以相同的方式用于创建 .wasm 文件。

1
2
3
4
5
C: emcc hello.c -s WASM=1 -o code秘密花园.html

C++: em++ hello.cpp -s WASM=1 -o code秘密花园.html

Rust: cargo build --target wasm --release

让我们来看看谁是狂野西部最快的枪……

为此,我们需要创建 2 个服务器

1.Golang服务器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import (
...
"fmt"
...
"net/http"
...
)

func main() {
...
fmt.Print("Golang: Server is running at http://localhost:8090/")
http.ListenAndServe(":8090", nil)
}

2. Node.js 服务器

1
2
3
4
5
6
7
8
9
10
11
const http = require('http');
...
(async () => {
...
http.createServer((req, res) => {
...
})
.listen(8080, () => {
console.log('Nodejs: Server is running at http://localhost:8080/');
});
})();

我们将测试每个任务的执行时间,注意:

  • 对于 Golang 服务器,它的延迟将是函数的直接执行时间 + 网络请求延迟
  • 而对于 Node.jsWebAssembly,它将只是函数的执行时间

最后的决斗

1.“ping”请求

只是检查一下一个请求执行将花费多少时间

Node.js

1
2
3
4
5
6
7
8
9
10
11
12
const nodejsPingHandler = (req, res) => {
console.time('Nodejs: ping');

const result = 'Pong';

console.timeEnd('Nodejs: ping');

res.statusCode = 200;
res.setHeader('Content-Type', 'application/json');
res.write(JSON.stringify({ result }));
res.end();
};

Golang

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// golang/ping.js

const http = require('http');

const golangPingHandler = (req, res) => {
const options = {
hostname: 'localhost',
port: 8090,
path: '/ping',
method: 'GET',
};

let result = '';

console.time('Golang: ping');

const request = http.request(options, (response) => {
response.on('data', (data) => {
result += data;
});
response.on('end', () => {
console.timeEnd('Golang: ping');

res.statusCode = 200;
res.setHeader('Content-Type', 'application/json');
res.write(JSON.stringify({ result }));
res.end();
});
});

request.on('error', (error) => {
console.error(error);
});

request.end();
};
1
2
3
4
5
// main.go

func ping(w http.ResponseWriter, req *http.Request) {
fmt.Fprintf(w, "Pong")
}

nodejs-golang

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// nodejs-golang/ping.js

const nodejsGolangPingHandler = async (req, res) => {
console.time('Nodejs-Golang: ping');

const result = global.GolangPing();

console.timeEnd('Nodejs-Golang: ping');

res.statusCode = 200;
res.setHeader('Content-Type', 'application/json');
res.write(JSON.stringify({ result }));
res.end();
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// main.go

package main

import (
"syscall/js"
)

func GolangPing(this js.Value, p []js.Value) interface{} {
return js.ValueOf("Pong")
}

func main() {
c := make(chan struct{}, 0)

js.Global().Set("GolangPing", js.FuncOf(GolangPing))

<-c
}

结果:

两个数字的简单求和

Node.js

1
2
const result = p1 + p2;

Golang

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
func sum(w http.ResponseWriter, req *http.Request) {
p1, _ := strconv.Atoi(req.URL.Query().Get("p1"))
p2, _ := strconv.Atoi(req.URL.Query().Get("p2"))

sum := p1 + p2

fmt.Fprint(w, sum)
}
````


nodejs-golang

```js
func GolangSum(this js.Value, p []js.Value) interface{} {
sum := p[0].Int() + p[1].Int()
return js.ValueOf(sum)
}

结果

计算斐波那契数列(第 100000 个数)

Node.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
const fibonacci = (num) => {
let a = BigInt(1),
b = BigInt(0),
temp;

while (num > 0) {
temp = a;
a = a + b;
b = temp;
num--;
}

return b;
};

Golang

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
func fibonacci(w http.ResponseWriter, req *http.Request) {
nValue, _ := strconv.Atoi(req.URL.Query().Get("n"))

var n = uint(nValue)

if n <= 1 {
fmt.Fprint(w, big.NewInt(int64(n)))
}

var n2, n1 = big.NewInt(0), big.NewInt(1)

for i := uint(1); i < n; i++ {
n2.Add(n2, n1)
n1, n2 = n2, n1
}

fmt.Fprint(w, n1)
}

nodejs-golang

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
func GolangFibonacci(this js.Value, p []js.Value) interface{} {
var n = uint(p[0].Int())

if n <= 1 {
return big.NewInt(int64(n))
}

var n2, n1 = big.NewInt(0), big.NewInt(1)

for i := uint(1); i < n; i++ {
n2.Add(n2, n1)
n1, n2 = n2, n1
}

return js.ValueOf(n1.String())
}

结果

计算 md5(10k 字符串)

Node.js

1
2
3
4
5
6
7
8
9

const crypto = require('crypto');

const md5 = (num) => {
for (let i = 0; i < num; i++) {
crypto.createHash('md5').update('nodejs-golang').digest('hex');
}
return num;
};

Golang

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
func md5Worker(c chan string, wg *sync.WaitGroup) {
hash := md5.Sum([]byte("nodejs-golang"))

c <- hex.EncodeToString(hash[:])

wg.Done()
}

func md5Array(w http.ResponseWriter, req *http.Request) {
n, _ := strconv.Atoi(req.URL.Query().Get("n"))

c := make(chan string, n)
var wg sync.WaitGroup

for i := 0; i < n; i++ {
wg.Add(1)
go md5Worker(c, &wg)
}

wg.Wait()

fmt.Fprint(w, n)
}

nodejs-golang

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
func md5Worker(c chan string, wg *sync.WaitGroup) {
hash := md5.Sum([]byte("nodejs-golang"))

c <- hex.EncodeToString(hash[:])

wg.Done()
}

func GolangMd5(this js.Value, p []js.Value) interface{} {
n := p[0].Int()

c := make(chan string, n)
var wg sync.WaitGroup

for i := 0; i < n; i++ {
wg.Add(1)
go md5Worker(c, &wg)
}

wg.Wait()

return js.ValueOf(n)
}

结果

计算 sha256(10k 字符串)

Node.js

1
2
3
4
5
6
7
8
9

const crypto = require('crypto');

const sha256 = (num) => {
for (let i = 0; i < num; i++) {
crypto.createHash('sha256').update('nodejs-golang').digest('hex');
}
return num;
};

Golang

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
func sha256Worker(c chan string, wg *sync.WaitGroup) {
h := sha256.New()
h.Write([]byte("nodejs-golang"))
sha256_hash := hex.EncodeToString(h.Sum(nil))

c <- sha256_hash

wg.Done()
}

func sha256Array(w http.ResponseWriter, req *http.Request) {
n, _ := strconv.Atoi(req.URL.Query().Get("n"))

c := make(chan string, n)
var wg sync.WaitGroup

for i := 0; i < n; i++ {
wg.Add(1)
go sha256Worker(c, &wg)
}

wg.Wait()

fmt.Fprint(w, n)
}

nodejs-golang

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
func sha256Worker(c chan string, wg *sync.WaitGroup) {
h := sha256.New()
h.Write([]byte("nodejs-golang"))
sha256_hash := hex.EncodeToString(h.Sum(nil))

c <- sha256_hash

wg.Done()
}

func GolangSha256(this js.Value, p []js.Value) interface{} {
n := p[0].Int()

c := make(chan string, n)
var wg sync.WaitGroup

for i := 0; i < n; i++ {
wg.Add(1)
go sha256Worker(c, &wg)
}

wg.Wait()

return js.ValueOf(n)
}

结果

最终结果

    1. Node.js,能很好地完成它的工作
    1. Golang 能很好地完成它的工作
    1. WebAssembly(现在还有我的 nodejs-golang 模块)能很好地完成它的工作
    1. Golang 可以用作独立应用程序,作为服务/微服务,作为 wasm 脚本的源,然后可以在 JavaScript 中被调用
  • 5 Node.jsGolang 都有现成的机制来在 JavaScript 中使用 WebAssembly

结论

快是好的,但准确才是一切。 - Wyatt Earp

    1. 如果有可能不用 Node.js 运行 CPU 密集型任务 - 最好不要这样做
    1. 如果你需要在 Node.js 中运行 CPU 密集型任务 - 可以先尝试使用 Node.js 执行此操作,可能性能没有你想象的那么差
    1. 在性能(使用其他语言)和可读性之间,最好选择可读性。如果你是唯一熟悉这个语言的人,则向项目添加这个新语言并不是一个好主意
    1. 对我来说,不同语言的服务最好 “保持分离”。你可以尝试为 CPU 密集型计算创建单独的服务或微服务,可以轻松扩展此类服务
    1. 首先,WebAssembly 对于浏览器来说是很好的,Wasm 二进制代码比 JS 代码更小,更容易解析,向后兼容等等,但是在 Node 服务中可能不是一个很好的选择

“一个优秀的架构师会假装还没有做出决定,并对系统进行反复的测试和优化,以便这些决定仍然可以尽可能长时间地推迟或更改。优秀的架构师会将未做决策的数量最大化。” - Robert C. Martin 的 Clean Architecture

如果你想加入高质量前端交流群,或者你有任何其他事情想和我交流也可以添加我的个人微信 ConardLi