在 Node.js 中引入 Golang ，会让它更快吗？

发表于 3年以前 | 总阅读数：731 次

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

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

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

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

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

测试项

尝试仅使用 Node.js 解决 CPU 密集型任务

2 . 创建单独使用 的Golang 编写的服务，并通过发送请求或消息队列的方式将其连接到应用里面

3 . 使用 Golang 构建 wasm 文件以运行 Node.js 中的某些方法

速度与金钱

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

Node.js（好人）

优点：

前后端使用相同的语言

2 . I/O 操作大师 - 超快的事件循环

3 . 最大的武器库 - npm

Golang（坏人）

优点：

由 Google 设计

2 . 几乎所有操作系统都支持

3 . “Goroutines” - Golang 中的特殊函数，可以与其他函数或方法同时运行（适用于 CPU 密集型任务）

4 . 简单 - 只有 25 个关键词

nodejs-golang/WebAssembly（丑陋的人）

优点：

随处可用

2 . 补充 JavaScript

3 . 可以用不同的语言编写代码并在 JavaScript 中使用 .wasm 脚本

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

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

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

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

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

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

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 文件。

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服务器

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 服务器

const http = require('http');
...
(async () => {
  ...
  http.createServer((req, res) => {
    ...
  })
  .listen(8080, () => {
    console.log('Nodejs: Server is running at http://localhost:8080/');
  });
})();

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

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

最后的决斗

1.“ping”请求

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

Node.js

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

// 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();
};

// main.go

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

nodejs-golang

// 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();
};

// 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

const result = p1 + p2;

Golang

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


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

结果

计算斐波那契数列（第 100000 个数）

Node.js

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

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

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

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


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


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

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

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

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)
}

结果