查看原文
其他

在 Node.js 中引入 Golang ,会让它更快吗?

ConardLi code秘密花园 2022-05-11

大家好,我是 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 文件:

    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.jsWebAssembly,它将只是函数的执行时间

    最后的决斗

    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',
        port8090,
        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)
    }

    结果

    最终结果


    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 。

    文中如有错误,欢迎在留言区和我留言,如果这篇文章帮助到了你,欢迎点赞、在看和关注。你的点赞、在看和关注是对我最大的支持!

    您可能也对以下帖子感兴趣

    文章有问题?点此查看未经处理的缓存