同一塊 QuickJS 晶片,插進六種不同的宿主 中間是一塊晶片,代表同一份 quickjs.c;六根長短粗細不同的線把它連到周圍六個形狀各異的插座上,代表 C、Rust、Go、Python、Node 和 Java 六種宿主,其中最短的一根是強調色。左邊寫著 7 ms、59 ms 和 fib(25),表示同一段程式碼在不同宿主裡跑出的時間。 7 ms … 61 ms fib(25) same quickjs.c

我們用同一份 JavaScript 檔案,在同一臺機器上,讓 QuickJS 跑了一遍 fib(25),只是每次換一個宿主語言(C 直接連結,其餘三個是各語言的繫結):

C quickjs-ng 0.17 7.2 ms
Rust rquickjs 0.14 7.6 ms
Go fastschema/qjs 22.8 ms
Java quickjs4j 0.1.1 60.6 ms

再讓宿主調 20 萬次指令碼里的 function add(a, b) { return a + b },每次呼叫的平均耗時差得更遠:C 是 21 納秒,Go 的 buke/quickjs-go 預設配置下是 34274 納秒。

QuickJS 是一個 C 寫的引擎,這幾次跑的 JavaScript 一個字都沒變,按理說宿主只是“把它裝進來”。那慢出來的時間是誰花掉的?是 Go、Java 這些語言本身慢,還是裝進來的方式不同?如果要在自己的程式裡嵌一個 QuickJS,選哪門語言、哪個繫結最合適?

我們先弄清楚 QuickJS 是什麼、它是怎樣被裝進別的語言裡的,再一項一項把這些差距拆開。

一、QuickJS 是什麼

一個能整個塞進別的程式裡的引擎

QuickJS 是 Fabrice Bellard(FFmpeg、QEMU 的作者)和 Charlie Gordon 寫的 JavaScript 引擎,2019 年 7 月第一次釋出1。它的目標不是和 V8 比峰值速度,而是小、能嵌進去:幾個 C 檔案,沒有外部依賴,一個 hello world 編出來只有 367 KiB 的 x86 程式碼;一個執行時例項從建立到銷燬不到 300 微秒;語言上支援到 ES20251。

小是靠取捨換來的。它沒有 JIT,原始碼進來之後只走一條很短的路:

QuickJS 的結構:宿主持有 JSRuntime 和 JSContext,原始碼一遍編譯成位元組碼再由直譯器執行 左邊是宿主程式裡呼叫的四個 C API:JS_NewRuntime、JS_NewContext、JS_Eval、JS_Call。右邊是 JSRuntime 內部:一個 JSContext 持有全域性物件和內建物件;fib 函式的原始碼經過一遍掃描的解析器直接變成 19 位元組的位元組碼,列出了 get_arg0、push_2、lt、if_false8、call1、add、return 等指令,最後交給 JS_CallInternal 裡的直譯器執行。JS_Eval 指向編譯器,JS_Call 指向直譯器。 宿主程式(C) JSRuntime · 一個堆、一個 GC JS_NewRuntime() 一個堆、一個垃圾回收器 JS_NewContext(rt) 一套全域性物件和內建物件 JS_Eval(ctx, src, …) 編譯並執行一段原始碼 JS_Call(ctx, fn, this, …) 呼叫一個 JS 函式 宿主拿到的每個 JSValue 都要自己 JS_FreeValue: QuickJS 靠引用計數回收, 再定期掃一遍環。 JSContext globalThis · Object · Array · JSON · RegExp … function fib(n) { return n < 2 ? n : fib(n-1) + fib(n-2) } 解析器 + 編譯器:一遍掃描,直接出位元組碼 位元組碼 · fib 19 位元組,棧深 4 get_arg0 · push_2 · lt · if_false8 7 · return get_var_ref0 · push_1 · sub · call1 · … · add 直譯器:JS_CallInternal 一條指令一條指令地執行
圖 1 · QuickJS 沒有 JIT:原始碼一遍編譯成位元組碼,之後一直由同一個 C 直譯器執行

這張圖裡有兩件事和後文直接相關。第一,JS 跑得快不快,全看這個 C 寫的直譯器迴圈被編譯成了什麼樣的機器碼。 它不會在執行中生成新程式碼,所以宿主語言既幫不上忙,也拖不了後腿,除非宿主改變了“這段 C 怎樣變成機器碼”。第二,宿主和引擎之間的每一次往來都是一個 C 函式呼叫:建一個數字要 JS_NewInt32,調函式要 JS_Call,用完要 JS_FreeValue。宿主語言呼叫 C 的代價,會乘上這些呼叫的次數。

兩個分支,很多個版本

同一個名字下面其實有兩份程式碼。 Bellard 在 2021 年 3 月釋出一版之後,將近三年沒有新版本。2023 年,Ben Noordhuis 和 Saúl Ibarra Corretgé 分叉出 quickjs-ng,按自己的節奏發版2;2024 年 1 月 Bellard 又恢復了釋出,此後兩邊各走各的3。各語言的繫結打包的是哪一邊、哪一版,全憑作者什麼時候更新過:

QuickJS 兩條分支的釋出時間線,以及各個繫結打包的是哪一版 上面一條是 Bellard 的 QuickJS:2019-07 首發,2021-03-27 之後近三年沒有釋出,2024-01-13 恢復,之後 2025-04-26、2025-09-13、2026-06-04。下面一條是 quickjs-ng:2023-11 釋出 v0.1.0,之後 v0.10.1、v0.12.1、v0.15.1、v0.16.2、v0.17.0。強調色圓點標出本文被測繫結實際打包的版本:Python quickjs 用 2021-03-27,quickjs-emscripten 用 2025-09-13,modernc 和 C 用 2026-06-04;fastschema 用 ng 0.10.1,quickjs-emscripten-ng 用 0.12.1,buke 用 0.15.1,rquickjs 用 0.16.2,Python quickjs-ng 和 C 用 0.17.0。 釋出時間線 · 強調色是本文被測繫結實際打包的版本 Bellard · bellard/quickjs quickjs-ng · quickjs-ng/quickjs 2019 2020 2021 2022 2023 2024 2025 2026 近三年沒有新版本 2023 年分叉 2019-07 2021-03-27 Python quickjs 2024-01 2025-04 2025-09-13 emscripten 2026-06-04 C · modernc v0.1 0.10.1 fastschema 0.12.1 emscripten-ng 0.15.1 buke 0.16.2 rquickjs 0.17 C · Python
圖 2 · 被測的十來個繫結,打包的引擎橫跨五年、兩個分支

版本之間的差距並不小。Bellard 在 2026-06-04 版的釋出說明裡寫的是“在 bench-v8 上比上一版快 42%”1;我們在本機用官方的 bench-v84 跑了一下兩個分支的最新版,Bellard 2026-06-04 得 1333 分,quickjs-ng 0.17 得 1131 分。後面比較宿主時,這是一個必須先剝離的變數。

那麼,同一份 C 程式碼是怎麼進到 Go、Python、Java 這些語言裡的?

二、同一份 C 程式碼進入宿主的三條路

三條路

一個 C 庫要被別的語言用,只有三種辦法:把它編譯成本機機器碼直接連結進去,把它編譯成一種可移植的中間格式再由宿主執行,或者把 C 原始碼翻譯成宿主語言的原始碼。QuickJS 的各個繫結三種都有:

QuickJS 進入宿主的三條路:原生連結、編成 WASM、翻譯成 Go 左邊是同一份原始碼 quickjs.c(約 6.5 萬行)加 libregexp、libunicode、dtoa。第一條路用 gcc 或 cc 編成機器碼 libqjs.a,直接連結進 C 程式、Rust(rquickjs)、Go(cgo)和 Python 的 C 擴充套件。第二條路用 clang 或 emscripten 編成 qjs.wasm,由 Go 的 wazero、Node 裡的 V8,或者翻譯成 JVM 位元組碼後由 Java 執行。第三條路用 ccgo 把 C 翻譯成 19.8 萬行的 Go 原始碼 ccgo_linux_amd64.go,再由 Go 編譯器編譯。 同一份原始碼 ① 編成本機機器碼,直接連結 ② 編成 WASM,由宿主的虛擬機器執行 ③ 把 C 翻譯成 Go 原始碼 C 原始碼 quickjs.c 約 6.5 萬行 libregexp.c libunicode.c dtoa.c 無外部依賴 gcc → libqjs.a C · Rust(rquickjs)· Go(cgo) Python C 擴充套件 · 跨語言要經過 FFI clang → qjs.wasm Go:wazero 把 WASM 再編成機器碼 Node:V8 的 WASM 編譯器 Java:構建期翻譯成 JVM 位元組碼 ccgo → *.go ccgo_linux_amd64.go · 19.8 萬行 Go
圖 3 · 同一份 C 程式碼,可以變成機器碼、WASM 或 Go 原始碼,宿主執行的東西因此完全不同

第一條路,執行的是 C 編譯器生成的機器碼,和 C 程式自己用沒有區別;代價在“跨語言呼叫”這一步,每種語言調 C 的機制(Go 的 cgo、Python 的擴充套件 API、Rust 的 FFI)各有開銷。第二條路,執行的是宿主的 WASM 引擎再生成的機器碼,好處是不需要 C 工具鏈、天然隔離,代價是 WASM 引擎的程式碼質量通常不如 GCC,而且每次進出 WASM 都要轉換引數。第三條路是 Go 特有的:ccgo 把 C 逐句翻譯成 Go,不用 cgo 也不用 WASM,但 C 裡的指標運算、malloc 都要由一個用 Go 寫的 libc(modernc.org/libc)來模擬。

被測的宿主

按這三條路,我們把各語言裡常見的 QuickJS 繫結都找了出來。Go 是我們的主力語言,所以 Go 的四種都測:cgo 的 buke/quickjs-go5、wazero 的 fastschema/qjs6、ccgo 翻譯的 modernc.org/quickjs7,再加一個我們自己寫的最薄 cgo 封裝;另外加一個不是 QuickJS 的 goja8 當對照。其他語言是 Rust 的 rquickjs9、Python 的兩個 C 擴充套件1011、Node 的 quickjs-emscripten12 和 Java 的 quickjs4j13:

被測宿主:繫結、打包的引擎版本、走哪條路
宿主繫結引擎路
C直接連結ng 0.17 / Bellard 2026-06-04① 原生
Rustrquickjs 0.14.0ng 0.16.2
Go
Go · bukebuke/quickjs-go v0.7.7ng 0.15.1① cgo
Go · 自寫本文寫的最薄 cgo 封裝ng 0.17
Go · fastschemafastschema/qjs v0.0.6ng 0.10.1② wazero
Go · moderncmodernc.org/quickjs v0.27.0Bellard 2026-06-04③ ccgo
Go · gojadop251/goja純 Go 引擎,不是 QuickJS對照
其他語言
Pythonquickjs 1.19.4Bellard 2021-03-27① C 擴充套件
Pythonquickjs-ng 0.17.0.2ng 0.17.0
Nodequickjs-emscripten 0.32.0Bellard 2025-09-13 / ng 0.12.1② V8
Javaquickjs4j 0.1.1Javy(rquickjs)② JVM
NodeV8 自己JIT,不是 QuickJS對照

機器:4 vCPU 的 Intel Xeon 2.1 GHz 雲主機,GCC 13.3、Go 1.26、Rust 1.97、Python 3.13、Node 22、JDK 21。

圖 4 · 十四個被測宿主,覆蓋三條路

所有宿主跑的是同一份 bench.js,裡面有三類純計算負載(fib(25)、5000 個物件的 JSON 序列化加排序、5000 行文字的正則和字串處理)、兩個用來測邊界的函式,以及一條讀 JSON 的業務規則。每個宿主跑 3 輪取中位數。

先看最基礎的問題:QuickJS 的直譯器本身,在不同宿主裡跑得一樣快嗎?

三、直譯器本身的速度

現象:從 0.8 倍到 12 倍

把三個純計算負載的耗時取幾何平均,以“C 直接連結 quickjs-ng 0.17”為 1 倍:

同一組純 JS 負載在各宿主裡的耗時,相對 C 直接連結 quickjs-ng 0.17 三個負載(fib、JSON、字串)耗時的幾何平均,以 C 直接連結 quickjs-ng 0.17 為 1 倍。V8 自己(JIT,參照) 0.19 倍;C · Bellard 2026-06 0.83 倍;C · ng 0.17 1.00 倍;Go · 自寫 cgo 1.06 倍;Rust · rquickjs 1.06 倍;Python · quickjs(2021 版) 1.29 倍;Go · buke(ng 0.15.1) 1.35 倍;Python · quickjs-ng wheel 1.46 倍;Node · emscripten 1.57 倍;Node · emscripten-ng 2.27 倍;Go · modernc(翻譯成 Go) 2.41 倍;Go · goja(不是 QuickJS) 3.55 倍;Go · fastschema(wazero) 3.60 倍;Java · quickjs4j 12.20 倍。原生連結的宿主都在 0.8 到 1.5 倍之間,WASM 和翻譯成 Go 的在 1.6 到 3.6 倍,JVM 上 12 倍。 純 JS 負載耗時(越短越快)· C 直接連結 ng 0.17 = 1× V8 自己(JIT,參照) 0.19× C · Bellard 2026-06 0.83× C · ng 0.17 1.00× Go · 自寫 cgo 1.06× Rust · rquickjs 1.06× Python · quickjs(2021 版) 1.29× Go · buke(ng 0.15.1) 1.35× Python · quickjs-ng wheel 1.46× Node · emscripten 1.57× Node · emscripten-ng 2.27× Go · modernc(翻譯成 Go) 2.41× Go · goja(不是 QuickJS) 3.55× Go · fastschema(wazero) 3.60× Java · quickjs4j 12.20× 直接把 C 編進宿主 WASM 或翻譯成別的語言 參照(不是 QuickJS)
圖 5 · 直接把 C 編進來的宿主都在 1 倍附近,換了執行方式才會差出幾倍

圖上的條形分成了明顯的幾組。直接連結 C 的宿主(強調色)都在 0.8 到 1.5 倍之間;走 WASM 或翻譯成 Go 的在 1.6 到 3.6 倍;JVM 上的 quickjs4j 是 12 倍。V8 自己跑同樣的指令碼只要 0.19 倍,那是 JIT 的功勞,不在本文的比較範圍裡。

原生這一組:差別來自引擎版本和編譯器

同屬第一條路,為什麼還有 0.83 倍和 1.46 倍之分? 按宿主語言去解釋是解釋不通的:Go 的 buke 比自寫的 cgo 封裝慢,Python 的兩個擴充套件一個慢在 JSON、一個慢在 fib。把它們打包的引擎單獨拿出來、用 C 重新編一遍,答案就出來了:

原生連結的幾種情況:同一份引擎原始碼,換宿主不換速度
引擎 · 宿主 · 編譯方式fib msJSON ms字串 ms
ng 0.17,GCC 13 -O2
C7.221.68.0
Go 自寫 cgo7.524.08.3
Rust rquickjs(ng 0.16.2,-O3)7.623.78.2
Python,本機從 sdist 編譯7.2–7.723.3–25.28.2–8.4
ng 0.15.1(buke 打包的版本)
Go buke7.635.711.3
C,同一份 0.15.1 原始碼7.432.910.2
其他
Python quickjs(Bellard 2021-03-27)6.732.912.0
Python quickjs-ng(PyPI wheel,GCC 14.2)17.923.79.1
C,Bellard 2026-06-046.017.36.9

Python 的“本機編譯”是用 pip 的 --no-binary 從同一個 0.17.0.2 原始碼包裝的,兩次執行的範圍。

圖 6 · buke 慢在 0.15.1 這一版本身,Python wheel 慢在編譯它的那個 GCC,都與宿主語言無關

buke 的 JSON 慢,是 0.15.1 慢。 把 buke 打包的那份 0.15.1 原始碼拿出來用 C 編,JSON 一樣是 33 毫秒;換成 0.17,Go 裡也是 24 毫秒。

Python quickjs-ng 的 fib 慢,是 PyPI 上那個預編譯包慢。 同一個 0.17.0.2 的原始碼包,在本機用 GCC 13 編出來,fib 回到 7 毫秒左右;PyPI 上的 manylinux wheel 是 GCC 14.2 編的,fib 要 17.9 毫秒。Bellard 在 2026 年 6 月修過一個“新版 GCC 下效能大幅退化”的問題14,原因是值型別 JSValue 裡一個只初始化了一半的 union 讓新 GCC 生成了更慢的程式碼。ng 0.17 已經帶了同樣的寫法,所以 wheel 慢的具體原因我們沒有完全確認,這裡只能推斷是編譯器版本或編譯引數的問題;能確認的是,換宿主語言不會讓它變快,換個編譯方式會。

Python quickjs 的 JSON 慢,是因為它打包的還是 2021 年的引擎。 它的 fib 不慢,說明 2021 年版的直譯器核心並不差,慢在後來幾年才最佳化的 JSON 和字串處理。

所以第一條路上的結論很乾脆:只要 C 程式碼是被編進來的,JS 執行速度就和宿主語言無關,只和“哪一版引擎、用什麼編譯器編”有關。 選繫結時,先看它打包的是什麼版本。

其他幾條路:執行方式決定量級

第二、三條路就不一樣了,執行的已經不是 GCC 生成的機器碼:

  • V8 跑 WASM(Node)約 1.6 倍。 V8 的 WASM 編譯器很成熟,兩個變體之間的差距(1.57 和 2.27 倍)主要還是引擎版本:一個是 Bellard 2025-09,一個是 ng 0.12.1。
  • wazero 跑 WASM(Go)約 3.6 倍。 wazero 是純 Go 寫的 WASM 執行時,它的編譯器後端比 V8 的簡單得多;fastschema 打包的 ng 0.10.1 也比較老。
  • ccgo 翻譯成 Go 約 2.4 倍。 翻譯出的 Go 程式碼要經過 Go 編譯器,所有記憶體操作都走 modernc 的 libc 模擬層。
  • JVM 約 12 倍。 quickjs4j 把 WASM 在構建期翻譯成 JVM 位元組碼,翻譯出來的方法非常大,HotSpot 預設不編譯超過 8000 位元組碼的方法;不加 -XX:-DontCompileHugeMethods,fib 要 513 毫秒,加上也還有 61 毫秒。

goja 不是 QuickJS,但它是 Go 裡最常見的替代品,3.55 倍和 wazero、modernc 在同一個量級。

到這裡還只解釋了開頭那組數字裡的一半:fib 慢 3 倍可以歸給 WASM,可同樣是 cgo,buke 調一次 add 要 34 微秒,比 C 慢了 1600 倍,又是為什麼?

四、跨邊界呼叫的代價

現象:一次 add 從 17 納秒到 34 微秒

嵌入指令碼的程式很少只讓 JS 悶頭算。更常見的是宿主一次次調 JS 函式(每來一個請求跑一次規則),或者 JS 一次次回撥宿主提供的函式(查一下配置、讀一個欄位)。我們測了三個量:宿主調 20 萬次 add(acc, 1);JS 裡迴圈 20 萬次調宿主註冊的 hostAdd;以及宿主把一段 JSON 字串傳進去、讓 JS 解析後判斷一條規則,跑 5 萬次。

跨邊界呼叫:每次的平均耗時
宿主宿主調 JSJS 調宿主一條 JSON 規則
C · Bellard 2026-0617 ns34 ns3.4 µs
C · ng 0.1721 ns44 ns4.0 µs
Rust · rquickjs82 ns113 ns4.4 µs
Go · 自寫 cgo89 ns79 ns4.2 µs
Python · quickjs138 ns148 ns7.0 µs
Python · quickjs-ng163 ns209 ns4.3 µs
Go · modernc294 ns625 ns12.4 µs
Go · goja(對照)329 ns777 ns26.1 µs
Go · buke 關掉檢查730 ns466 ns10.0 µs
Node · emscripten1.6 µs3.3 µs14.6 µs
Java · quickjs4j—17.6 µs—
Go · fastschema(wazero)29.9 µs31.1 µs49.8 µs
Go · buke 預設34.3 µs10.9 µs36.2 µs

“JS 調宿主”包含 JS 自己迴圈一次的開銷(C 里約 43 ns)。quickjs4j 只能透過 JSON 序列化呼叫 JS 函式,沒有測宿主調 JS。

圖 7 · 計算速度一樣的幾個原生宿主,邊界開銷能差出 400 倍

這張表的排序和圖 5 很不一樣。buke 在純計算上和 C 一樣快,在邊界上卻是最慢的;Python 的計算不算快,邊界卻只比 Rust 慢一點。邊界開銷顯然另有來源。

原因一:buke 每個 API 都在查“我是不是在原來那個 goroutine 上”

用 pprof 看 buke 調 add 的過程,94% 的時間花在一個叫 currentGoroutineID 的函式里,它呼叫 runtime.Stack 把當前 goroutine 的棧列印成文字,再從文字里解析出 goroutine 編號。buke 在 Runtime、Context、Value 的幾乎每個方法前都做這個“屬主檢查”,防止別的 goroutine 併發訪問同一個執行時5。一次 add 要建兩個數、調一次、取結果、釋放三個值,一共約十次檢查,每次約 3 微秒。

從 Go 調一次 add(acc, 1):buke 要跨約十次邊界,自寫封裝只跨一次 左邊是 buke 完成一次 add 的呼叫序列:NewInt32(acc)、NewInt32(1)、Execute 也就是 JS_Call、ToInt32、三次 Free,以及內部的 NewUndefined、IsUndefined,每一步都是一次 cgo 呼叫,前面還有一次用 runtime.Stack 做的屬主檢查。預設 34.3 微秒,關掉檢查後 730 納秒。右邊是自寫封裝:Go 只調一次 eng_call,在 C 裡完成建數、JS_Call、取結果、釋放,89 納秒;C 自己做同樣的事 21 納秒。下方是 fastschema 的情況:每次進 WASM 前都呼叫 ExportedFunction 查一次匯出函式,3075 納秒;把查到的函式快取起來,一次呼叫只要 32 納秒。 buke:每一步都是一次 cgo 呼叫 自寫封裝:只過一次 cgo fastschema:每次進 WASM 先查一次匯出函式 Go 方法 → C 函式 每步前:runtime.Stack 查屬主 ctx.NewInt32(acc)JS_NewInt32 ctx.NewInt32(1)JS_NewInt32 fn.Execute(g, x, y)JS_NewUndefined · JS_Call r.ToInt32()JS_ToInt32 r.Free() · x.Free() · y.Free()JS_FreeValue × 3 約 10 次 cgo,每次 50–70 ns 約 10 次屬主檢查,每次約 3 µs 預設 34.3 µs 關掉屬主檢查 730 ns Go → C 一次 eng_call(e, ADD, acc, 1) JS_NewInt32 × 2 JS_Call JS_ToInt64 JS_FreeValue 以上都在 C 裡完成 一次 89 ns C 自己做同樣的事:21 ns m.ExportedFunction("QJS_Call").Call(…) 每次新建函式例項和呼叫棧:3075 ns f := m.ExportedFunction(…);f.Call(…) 查一次、快取起來反覆用:32 ns
圖 8 · 慢的不是 cgo 或 WASM 本身,而是繫結把一次邏輯呼叫拆成了很多次,並且每次都做了昂貴的額外工作

buke 提供了 WithOwnerGoroutineCheck(false) 關掉這個檢查,代價是呼叫方自己保證一個執行時只在一個 goroutine 上用5。關掉之後一次 add 是 730 納秒,剩下的就是約十次 cgo 呼叫本身,每次 50 到 70 納秒。

原因二:cgo 一次往返本身多貴

cgo 每次呼叫要在 Go 的排程器上登記“這個執行緒進 C 了”,出來時再登記回去,這是它比普通函式呼叫貴的原因。為了看清這筆開銷的下限,我們寫了一個最薄的封裝:Go 只調一次 C 函式 eng_call,建數、呼叫、取結果、釋放全在 C 裡做完。這樣一次 add 是 89 納秒,減去 C 自己的 21 納秒,一次 cgo 往返大約 70 納秒。封裝的核心只有這麼幾行:

Go
/*
#include "quickjs.h"
typedef struct { JSRuntime *rt; JSContext *ctx; JSValue fn[8]; } eng;
// 一次逻辑调用在 C 里做完:建参数、调用、取结果、释放
static int64_t eng_call(eng *e, int f, int argc, int32_t a, int32_t b) {
JSValue argv[2] = { JS_NewInt32(e->ctx, a), JS_NewInt32(e->ctx, b) };
JSValue r = JS_Call(e->ctx, e->fn[f], JS_UNDEFINED, argc, argv);
int64_t v = 0;
JS_ToInt64(e->ctx, &v, r);
JS_FreeValue(e->ctx, r);
return v;
}
*/
import "C"
func (e *Engine) Call(fn int, a, b int32) int64 {
return int64(C.eng_call(e.e, C.int(fn), 2, C.int32_t(a), C.int32_t(b)))
}

函式控制代碼在建立執行時時就取好存進 fn[],Go 這邊每次只傳一個下標。

反方向也一樣:JS 調一個用 Go 寫的 hostAdd 要 79 納秒,把 hostAdd 換成 C 實現是 42 納秒,C 回撥 Go 大約多出 35 到 40 納秒。

Rust(82 納秒)和 Python(138 到 163 納秒)的數字也在這個量級。Rust 調 C 本身沒有額外開銷,rquickjs 多出來的時間花在它的安全包裝上,比如每次呼叫前都更新一次棧頂(第六節會講為什麼要這麼做)。Python 每次呼叫都要把 Python 的 int 轉成 JSValue、再把結果轉回來,這在 CPython 裡本來就是這個價錢。

原因三:fastschema 每次進 WASM 都查一次函式表

fastschema 的 30 微秒有著類似的來歷。它每次呼叫 WASM 裡的函式,都寫成 m.ExportedFunction("QJS_Call").Call(...),而 wazero 的 ExportedFunction 每次都會新建一個函式例項、分配一塊呼叫棧15。我們繞過 fastschema、直接用 wazero 載入它的 qjs.wasm 做了對比:同一個匯出函式,每次查詢再呼叫是 3075 納秒,查一次快取起來是 32 納秒,差了近 100 倍。一次 add 在 fastschema 裡要進出 WASM 十來次,於是成了 30 微秒。

WASM 的邊界本身並不貴,32 納秒比 cgo 還便宜,因為 wazero 呼叫 WASM 不需要切換到系統棧,也不需要通知排程器。貴的是繫結的寫法。Node 的 quickjs-emscripten 每次呼叫 1.6 微秒則是另一種情況:它的每個引數、返回值都是一個要手動 dispose 的控制代碼物件,一次呼叫要經過好幾次 JS 和 WASM 之間的轉換。

回到業務規則

最後一列“JSON 規則”更接近真實場景:宿主把一個 JSON 字串傳進去,JS 解析、判斷,返回 0 或 1。它本身要做 3 到 4 微秒的事,所以邊界開銷只要在一兩百納秒以內就看不出來:C、Rust、Go 自寫封裝、Python quickjs-ng 都在 4.0 到 4.4 微秒。buke 預設配置下是 36 微秒,fastschema 是 50 微秒,邊界開銷比正事還多十倍。

單次呼叫的成本弄清楚了,下一個問題是:一臺機器上要同時跑很多段指令碼時,又是什麼情況?

五、啟動、記憶體與併發

每來一個請求新建一個執行時,行不行

QuickJS 宣傳的“300 微秒內完成一個執行時的生命週期”,是很多人選它的原因:每個請求一個全新的執行時,指令碼之間互不干擾。我們測了新建執行時和上下文、執行 1+1、銷燬的耗時,以及保持 200 個載入了 bench.js 的例項時平均每個佔多少記憶體:

啟動、記憶體和多執行緒吞吐
宿主新建一個執行時每個例項記憶體1 / 2 / 4 執行緒吞吐(次/秒)
C · ng 0.17104 µs170 KB—
Rust · rquickjs106 µs182 KB119 / 243 / 421
Go · buke 關掉檢查304 µs117 KB129 / 254 / 496
Go · modernc198 µs165 KB46 / 24 / 21
Go · fastschema(wazero)3.4 ms,程序內首次 0.77 s660 KB33 / 53 / 78
Go · goja(對照)11 µs35 KB34 / 68 / 115
Python · quickjs176 µs55 KB134 / 261 / 459
Python · quickjs-ng115 µs167 KB56 / 108 / 211
Node · emscripten209 µs54 KB—
Java · quickjs4j9.0 ms——

吞吐:1、2、4 個執行緒(goroutine)各自持有一個執行時,迴圈跑 fib(25),4 vCPU。記憶體是 200 個例項的 RSS 增量平均值,各版本內建物件多少不同,只看量級。

圖 9 · 原生的幾種都能一個請求一個執行時;wazero 的首次編譯和 modernc 的併發是兩個例外

原生的幾種新建一個執行時都在 0.1 到 0.3 毫秒,每個例項一兩百 KB,“一個請求一個執行時”是可行的。表裡有三處需要單獨解釋。

fastschema 程序裡第一次建立執行時要 0.77 秒。 wazero 要先把 1 MB 的 qjs.wasm 編譯成機器碼,這一步在每個程序裡做一次(可以配置磁碟快取),之後每個執行時 3.4 毫秒,因為每個例項都要分配並初始化一塊獨立的 WASM 線性記憶體。對命令列工具、Serverless 這類短命程序,這 0.77 秒很可能比指令碼本身還長。

modernc 執行緒越多越慢。 QuickJS 的執行時是單執行緒的,想用滿多核只能開多個執行時,各跑各的;原生繫結基本能線性擴充套件。modernc 從 1 個 goroutine 的 46 次/秒掉到 4 個的 21 次/秒,原因在它模擬 C 標準庫的 modernc.org/libc:malloc 和 free 共用一把全域性互斥鎖 allocMu,QuickJS 分配又極其頻繁,多個執行時就全卡在這把鎖上。

Python 的兩個擴充套件都能多執行緒擴充套件。 它們在執行 JS 期間釋放了 GIL(Py_BEGIN_ALLOW_THREADS)10,所以多個執行緒各持一個 Context 時真的是並行的。

goja 新建只要 11 微秒,因為它的“執行時”就是普通的 Go 物件,不需要初始化一整套 C 結構;這也是它在 Go 裡的主要優勢。

效能之外,嵌入一個 C 引擎還有一類問題會直接讓程序掛掉,它也和宿主的執行緒模型有關。

六、棧、執行緒與崩潰

現象:沒有遞迴,卻報“棧溢位”

寫自用的 cgo 封裝時,我們第一次跑規則測試,5 萬次裡有 3.6 萬次返回了異常:Maximum call stack size exceeded。規則只是解析一段 JSON,根本沒有遞迴。

原因:QuickJS 記住的是建立時那個執行緒的棧

QuickJS 防止 JS 無限遞迴把 C 棧耗盡的辦法,是在建立執行時時記下當前的棧頂地址,之後每次進入函式都比較“當前棧指標離棧頂有多遠”,超過上限(預設 1 MB)就拋異常。這個辦法預設了一件事:執行時永遠在同一個執行緒、同一塊棧上執行。 在 C 裡這是自然而然的,在 Go 裡卻不是:goroutine 會被排程器換到別的 OS 執行緒上,cgo 呼叫發生在哪個執行緒,取決於這個 goroutine 當時在哪。

goroutine 換了執行緒,QuickJS 按舊執行緒的棧頂判斷,誤報棧溢位 實測輸出:JS_NewRuntime 線上程 13632 執行,棧地址 0x7ffdcbd576a4,QuickJS 記下這個棧頂。第 0 次呼叫也線上程 13632,結果正常。第 1 次呼叫 goroutine 被換到執行緒 13635,棧地址 0x7f23f199dddc,與記下的棧頂相差 0xd9da3b98c8 位元組(約 0.85 TB),遠超 1 MB 的上限,於是丟擲 Maximum call stack size exceeded,此後每次都失敗。解決辦法是 runtime.LockOSThread 或者每次呼叫前 JS_UpdateStackTop。 OS 執行緒 13632(主執行緒) OS 執行緒 13635 JS_NewRuntime() 記下棧頂 棧地址 0x7ffdcbd576a4 上限 往下 1 MB 以內 第 0 次呼叫 sp 0x7ffdcbd5767c ok goroutine 被排程器換到別的執行緒 第 1 次起的每次呼叫 同一個執行時 sp 0x7f23f199dddc 離記下的棧頂 約 0.85 TB Maximum call stack size exceeded 虛線:並沒有遞迴,是按錯的 棧頂算出來的“溢位” 解決:執行時所在 goroutine 調 runtime.LockOSThread(),或者每次呼叫前 JS_UpdateStackTop
圖 10 · 棧深檢查假設執行時一直在同一個執行緒上,Go 的 goroutine 不滿足這個假設

兩個地址相差約 0.85 TB,自然“超過了 1 MB 的上限”。解決辦法有兩個:讓持有執行時的 goroutine 調 runtime.LockOSThread() 釘在一個執行緒上;或者像 rquickjs 那樣,每次呼叫前執行一次 JS_UpdateStackTop,按當前執行緒重新記棧頂9。Rust 裡沒有 goroutine 排程,rquickjs 這樣做是為了支援執行時線上程間移動,這也是它的單次呼叫比 C 多出幾十納秒的原因之一。

現成的 Go 繫結怎麼處理:一個關了檢查,一個崩成 panic

那 buke 為什麼沒有這個問題? 因為它預設把棧深上限設成了 0,也就是不檢查5。代價是真的無限遞迴時,沒有人攔著:

執行 function r(n){ return r(n+1) + 1 } 之後
宿主結果
Go · buke 預設SIGSEGV,整個程序退出
Go · buke + WithMaxStackSize(1<<20)JS 裡拋 RangeError,可以 catch
Go · fastschema(wazero)Go panic:wasm error: out of bounds memory access
Go · moderncJS 裡拋 InternalError: stack overflow
Rust · rquickjs、Python 兩個擴充套件JS 裡拋異常,可以 catch
Node · emscripten宿主側拋 RangeError(V8 的棧先滿了)

指令碼用 try/catch 包住了遞迴,“可以 catch”指指令碼自己能接住,宿主繼續正常執行。

圖 11 · 同一段惡意指令碼,有的繫結當作普通異常,有的直接讓程序退出

如果指令碼來自使用者,這張表比前面所有效能數字都重要。buke 的預設配置下,一行遞迴就能讓整個服務退出;fastschema 會變成 Go 的 panic,雖然能 recover,但這個執行時的狀態已經不可信,只能丟掉。

到這裡,開頭的幾組數字都找到了出處。最後回答那個問題:嵌在哪裡最好?

七、回到開頭:嵌在哪裡最好

先把開頭的現象逐一對上:

  • fib 7.2 和 7.6 毫秒:C 和 Rust 執行的是同一類 GCC 機器碼,差別在引擎小版本和編譯引數。
  • fastschema 的 22.8 毫秒、quickjs4j 的 60.6 毫秒:它們執行的不是 GCC 生成的機器碼,而是 wazero 和 JVM 從 WASM 再生成的程式碼,慢在執行方式。
  • buke 的 34 微秒一次 add:既不是 Go 慢,也不是 cgo 慢,而是繫結在每個 API 上做了一次 runtime.Stack。

所以“QuickJS 嵌在哪門語言裡表現最好”的答案是:只要走第一條路,把 C 直接編進去,語言本身幾乎不影響 JS 的執行速度;真正拉開差距的是繫結打包的引擎版本、執行方式,以及繫結在邊界上怎麼寫。 只看數字,C 和 Rust 最好,Python 意外地不差(邊界一兩百納秒、執行時釋放 GIL),Node 裡用它只適合需要沙箱的場合,Java 目前的選擇還很慢。

對 Go 來說,選擇取決於能不能接受 cgo:

Go 程式嵌入 QuickJS 的選擇 第一個問題:能接受 cgo 嗎。能:用 buke 時一定要加 WithMaxStackSize,並在確認單 goroutine 使用時關掉屬主檢查,或者自己寫一層把一次邏輯呼叫合成一次 cgo 並 LockOSThread,計算 1 倍,邊界約 90 納秒。不能:再問需要多核併發嗎。需要:fastschema 計算約 3.6 倍、邊界 30 微秒、首次啟動 0.77 秒,或者不堅持 QuickJS 用 goja。不需要:modernc 計算約 2.4 倍、邊界約 300 納秒,但多 goroutine 會變慢。 在 Go 裡嵌 QuickJS 能接受 cgo 嗎? 能 不能 需要多個 goroutine 同時跑指令碼嗎? 需要 不需要 cgo 繫結 計算 1×,邊界 ~90 ns 到 0.7 µs buke:WithMaxStackSize(1<<20) 必加 單 goroutine 使用時 WithOwnerGoroutineCheck(false) 邊界很密:自己封一層,一次邏輯呼叫只過一次 cgo, 並 runtime.LockOSThread() fastschema/qjs(wazero)或乾脆用 goja fastschema:計算 3.6×,邊界 30 µs,程序首次 0.77 s,能多核擴充套件 goja:計算 3.6×,邊界 0.3–0.8 µs,新建 11 µs,不是 QuickJS modernc.org/quickjs 計算 2.4×,邊界 ~0.3 µs,異常處理正常;多 goroutine 反而變慢
圖 12 · Go 裡最快的是 cgo,但要自己補上棧深上限;不用 cgo 時,按是否需要併發在 wazero、goja 和 modernc 之間選

能用 cgo,就用 cgo:計算速度和 C 一樣,但 buke 的兩個預設值都要改,一個關乎效能(屬主檢查),一個關乎程序會不會被一行指令碼打崩(棧深上限)。如果宿主和 JS 之間來往特別頻繁,自己寫一層薄封裝是值得的,一次往返從 730 納秒降到 89 納秒。

不能用 cgo(要交叉編譯、要靜態二進位制、不想裝 C 工具鏈)時,三個純 Go 方案各有一個硬傷:fastschema 的邊界開銷和首次編譯,modernc 的併發,goja 不是 QuickJS(如果需要和 QuickJS 完全一致的行為,比如同一份指令碼要在 C 端也跑)。附帶一個數字:只執行 1+1 的最小程式,-s -w 編譯後 buke 是 2.9 MB,modernc 5.2 MB,fastschema 6.3 MB,goja 10.6 MB;後三者 CGO_ENABLED=0 交叉編譯到 arm64 都能直接透過,buke 不行。

小結

  1. QuickJS 是什麼? 一個幾個 C 檔案、無依賴、沒有 JIT 的 JavaScript 引擎:原始碼一遍編譯成位元組碼,由 C 直譯器執行;宿主透過 JS_NewRuntime、JS_Call 這些 C 函式和它打交道。Bellard 原版和 quickjs-ng 兩個分支並行發版,各繫結打包的版本橫跨五年。
  2. 同一份 C 程式碼怎麼進入別的語言? 三條路:編成機器碼直接連結(C、Rust、Go cgo、Python 擴充套件),編成 WASM 由宿主執行(Go wazero、Node、Java),翻譯成 Go 原始碼(modernc)。
  3. 直譯器速度和宿主語言有關嗎? 走第一條路時無關,差別來自引擎版本(ng 0.15.1 比 0.17 的 JSON 慢 50%,Python quickjs 還是 2021 年的引擎)和編譯器(同一個原始碼包,PyPI wheel 的 fib 慢 2.4 倍)。走 WASM 或翻譯時,慢 1.6 到 12 倍,取決於執行它的虛擬機器。
  4. 邊界呼叫為什麼能差 400 倍? cgo 往返約 70 納秒、wazero 呼叫約 32 納秒,本身都不貴;buke 的屬主檢查(runtime.Stack,每次約 3 微秒)和 fastschema 每次 ExportedFunction(約 3 微秒)把一次邏輯呼叫變成了 30 多微秒。
  5. 啟動和併發呢? 原生繫結新建一個執行時 0.1 到 0.3 毫秒,可以一個請求一個;wazero 程序內首次要 0.77 秒;modernc 的 libc 有全域性分配鎖,多 goroutine 反而變慢;Python 擴充套件執行 JS 時釋放 GIL,能多執行緒擴充套件。
  6. 還有什麼會讓程序掛掉? QuickJS 按建立時的執行緒記棧頂,Go 的 goroutine 換執行緒就會誤報棧溢位,要 LockOSThread 或 JS_UpdateStackTop;buke 預設關掉棧深檢查,一行無限遞迴就能讓程序段錯誤退出。
  7. 嵌在哪裡最好? 只看引擎,C 和 Rust 最好,Python 也不差;在 Go 裡優先用 cgo 繫結並改掉兩個預設值,邊界密集時自己封一層;不能用 cgo 時按是否需要併發在 wazero、modernc 和 goja 之間取捨。

參考資料

參考資料

  1. QuickJS Javascript EngineFabrice Bellard · bellard.orgbellard.org ↗官網:幾個 C 檔案、無外部依賴,hello world 367 KiB x86 程式碼;執行時例項完整生命週期不到 300 微秒;支援 ES2025;引用計數加環檢測。2026-06-04 版“比上一版在 bench-v8 上快 42%”。https://bellard.org/quickjs/ ↩ ↩2 ↩3

  2. quickjs-ng/quickjsGitHubgithub.com ↗“a fork of the original QuickJS project … after it went dormant”,維護者 Ben Noordhuis、Saúl Ibarra Corretgé。v0.1.0 釋出於 2023-11-23,文中 C 宿主用 v0.17.0 之後的 main(7a23d8e)。https://github.com/quickjs-ng/quickjs ↩

  3. bellard/quickjs:ChangelogGitHubgithub.com ↗各版本改動。2026-06-04:小塊自定義 malloc(bench-v8 快 11%)、微最佳化(快 30%)。2021-03-27 之後到 2024-01-13 之間沒有釋出。https://github.com/bellard/quickjs/blob/master/Changelog ↩

  4. QuickJS extras:tests/bench-v8bellard.orgbellard.org ↗V8 benchmark suite v7 的合併版 combined.js,QuickJS 官網的效能數字就是用它測的。https://bellard.org/quickjs/quickjs-extras-2026-06-04.tar.xz ↩

  5. buke/quickjs-goGitHubgithub.com ↗cgo 繫結,文中用 v0.7.7,打包 quickjs-ng v0.15.1。WithOwnerGoroutineCheck、WithMaxStackSize 兩個選項見 runtime.go;預設 maxStackSize 為 0。https://github.com/buke/quickjs-go ↩ ↩2 ↩3 ↩4

  6. fastschema/qjsGitHubgithub.com ↗把 quickjs-ng 編成 WASM(-O3 + wasm-opt),用 wazero 在 Go 裡跑,不需要 cgo。文中用 v0.0.6,內嵌 qjs.wasm 為 ng 0.10.1。https://github.com/fastschema/qjs ↩

  7. modernc.org/quickjsGitLabgitlab.com ↗用 ccgo 把 Bellard 版 QuickJS 的 C 原始碼翻譯成 Go。文中用 v0.27.0(libquickjs v0.14.0,對應 2026-06-04 版),linux/amd64 的翻譯結果是一個 19.8 萬行的 ccgo_linux_amd64.go。https://gitlab.com/cznic/quickjs ↩

  8. dop251/gojaGitHubgithub.com ↗純 Go 寫的 ECMAScript 引擎,不是 QuickJS,作為 Go 裡的對照。https://github.com/dop251/goja ↩

  9. DelSkayn/rquickjsGitHubgithub.com ↗Rust 繫結,文中用 0.14.0,打包 quickjs-ng 0.16.2;每次呼叫前執行 JS_UpdateStackTop(rquickjs-core 的 args.rs)。https://github.com/DelSkayn/rquickjs ↩ ↩2

  10. PetterS/quickjs(PyPI:quickjs)GitHubgithub.com ↗Python C 擴充套件,文中用 1.19.4;sdist 裡的 upstream-quickjs/VERSION 是 2021-03-27。執行 JS 時 Py_BEGIN_ALLOW_THREADS 釋放 GIL。https://github.com/PetterS/quickjs ↩ ↩2

  11. genotrance/quickjs-ng(PyPI:quickjs-ng)GitHubgithub.com ↗PetterS 版的分支,換成 quickjs-ng 0.17.0,文中用 0.17.0.2。PyPI 上的 manylinux wheel 由 GCC 14.2.1 編譯。https://github.com/genotrance/quickjs-ng ↩

  12. justjake/quickjs-emscriptenGitHubgithub.com ↗用 emscripten 編成 WASM,在 Node / 瀏覽器裡跑。文中用 0.32.0 的兩個變體:@jitl/quickjs-wasmfile-release-sync(Bellard 2025-09-13)和 @jitl/quickjs-ng-wasmfile-release-sync(ng 0.12.1)。https://github.com/justjake/quickjs-emscripten ↩

  13. roastedroot/quickjs4jGitHubgithub.com ↗Java 繫結,文中用 0.1.1:Javy 外掛(內部是 rquickjs)編成 WASM,再在構建期翻譯成 JVM 位元組碼。https://github.com/roastedroot/quickjs4j ↩

  14. bellard/quickjs 10c81b1:fixed large performance regression with recent GCC versionsGitHub · 2026-06-03github.com ↗JSValueUnion 的 int32 欄位改成 uint64:“avoid uninitialized data by using a 64 bit field even if only 32 bits are needed because some compilers generate slower code”。https://github.com/bellard/quickjs/commit/10c81b1989de2d2e8d482d252b160a34f215d3e2 ↩

  15. tetratelabs/wazeroGitHubgithub.com ↗純 Go 的 WebAssembly 執行時,amd64/arm64 預設用編譯器後端。文中版本 v1.9.0;Module.ExportedFunction 每次呼叫都會新建一個函式例項。https://github.com/tetratelabs/wazero ↩