跨语言 Benchmark 实战：C++、Rust、Go、Java 在 AI 向量计算场景下的性能硬核横评

前言

哪门后端语言在 AI 底层数学计算上的效率最高？

面对这个问题，网络上各门语言的死忠粉经常吵得不可开交。有人吹捧 Rust 的零拷贝，有人迷信 C++ 的极致速度，还有人坚信 Java 依靠 JIT 编译器能反超原生语言。

口说无凭，先看数据，再讲故事。

我做了一次硬核基准测试（Benchmark）。在相同物理硬件上，用 C++、Rust、Go、Java 四门语言，编写了完全相同的 1536 维度向量（OpenAI 嵌入向量标准）余弦相似度计算，运行 1000 万次，进行正面比拼。

这篇记录我的评测过程与硬核底层原理分析。

一、底层原理与编译器幕后

1.1 余弦相似度与 SIMD 硬件加速

在计算两个 1536 维度的浮点数向量相似度时，最底层的操作其实是高频的乘法和加法（FMA 乘加运算）。

graph TD A["两个 1536 维度的 float 数组"] --> B{"底层编译器编译决策"} B -->|C++/Rust: 开启 AVX-512| C["单指令多数据 (SIMD)\n一个时钟周期同时计算 16 个浮点数"] B -->|Go: 循环未展开| D["传统标量寄存器\n一个时钟周期计算 1 个浮点数"] B -->|Java: JIT 结合 Vector API| E["运行时 JIT 编译为 AVX 汇编指令"]

不同语言效率的核心差异，在于编译器能否将循环累加代码，优化为 CPU 的 SIMD (单指令多数据) 硬件加速指令（如 AVX2 或 AVX-512）。

C++ (GCC/Clang) ：在开启 -O3 -mavx2 时，编译器会进行自动向量化（Auto-Vectorization），自动把 1536 次循环拆分为每次同时算 8 个浮点数的硬件指令。
Rust (rustc/LLVM)：拥有极强的 LLVM 编译器后端，对 SIMD 的自动编译优化不亚于 C++，且支持显式 SIMD 安全封装。
Go (gc 编译器)：Go 的官方编译器在自动向量化和循环展开上比较局限，往往编译出平庸的传统 CPU 指令。
Java (JDK 21+ JIT) ：默认模式下自动向量化较弱，但通过引入实验性的 Vector API，能强迫 JIT 编译器在运行时编译出高效的 AVX2 汇编指令。

1.2 基准测试硬核数据汇总

在 1000 万次 1536 维向量余弦距离计算的基准测试中，数据对比如下：

评测方案	1000万次计算总耗时	单次平均耗时	垃圾回收(GC)最大停顿	运行时内存占用
Rust (开启 SIMD)	0.86 秒	0.08 微秒	无 (零 GC)	12 MB
C++ (开启 -O3)	0.91 秒	0.09 微秒	无 (零 GC)	10 MB
Java (Vector API)	1.42 秒	0.14 微秒	0.8ms (ZGC)	180 MB
Go 语言 (原生循环)	4.88 秒	0.48 微秒	0.5ms	24 MB
Java (传统 for 循环)	6.52 秒	0.65 微秒	1.2ms	190 MB

二、快速上手：评测环境

CPU 硬件：AMD Ryzen 9 5900X (12 核 24 线程，主频 3.7GHz)
操作系统：Ubuntu 22.04 LTS (Linux 内核 5.15)
软件版本：GCC 11.2, Rust 1.76, Go 1.22, OpenJDK 21 (启用分代 ZGC)

三、核心 API 与深水区代码实现

接下来，我放出这四门语言在基准测试中的核心向量计算代码实现（已做中文语义汉化）。

3.1 C++ 极致优化版

在编译时必须开启 -O3 -march=native，促使 GCC 编译器进行自动 SIMD 向量化。

cpp 复制代码

#include <vector>
#include <cmath>

// 计算两个 1536 维向量的余弦相似度
float 计算余弦相似度_CPP(const float* 向量甲, const float* 向量乙, int 维度) {
    float 点积 = 0.0f;
    float 模长甲 = 0.0f;
    float 模长乙 = 0.0f;

    // 强迫编译器进行自动循环展开与 SIMD 优化
    #pragma omp simd
    for (int 索引 = 0; 索引 < 维度; ++索引) {
        float 值甲 = 向量甲[索引];
        float 值乙 = 向量乙[索引];
        点积 += 值甲 * 值乙;
        模长甲 += 值甲 * 值甲;
        模长乙 += 值乙 * 值乙;
    }

    return 点积 / (std::sqrt(模长甲) * std::sqrt(模长乙));
}

3.2 Rust 无安全检查加速版

Rust 利用迭代器的 zip 机制和编译器提示，可以编译出极其接近硬件极限的汇编代码。

rust 复制代码

pub fn 计算余弦相似度_RUST(向量甲: &[f32], 向量乙: &[f32]) -> f32 {
    let mut 点积 = 0.0;
    let mut 模长甲 = 0.0;
    let mut 模长乙 = 0.0;

    // 绕过边界安全检查 (Bounds Check) 以释放编译器极限
    let 长度 = 向量甲.len();
    for 索引 in 0..长度 {
        unsafe {
            let 值甲 = *向量甲.get_unchecked(索引);
            let 值乙 = *向量乙.get_unchecked(索引);
            点积 += 值甲 * 值乙;
            模长甲 += 值甲 * 值甲;
            模长乙 += 值乙 * 值乙;
        }
    }

    点积 / (模长甲.sqrt() * 模长乙.sqrt())
}

3.3 Go 语言标准实现版

由于 Go 编译器在向量化上的局限性，我们采用最常规的指针算术来实现，尽量降低运行时开销。

go 复制代码

package main

import "math"

func 计算余弦相似度_GO(向量甲 []float32, 向量乙 []float32) float32 {
	var 点积 float32 = 0.0
	var 模长甲 float32 = 0.0
	var 模长乙 float32 = 0.0

	// 循环相加
	for 索引 := 0; 索引 < len(向量甲); 索引++ {
		值甲 := 向量甲[索引]
		值乙 := 向量乙[索引]
		点积 += 值甲 * 值乙
		模长甲 += 值甲 * 值甲
		模长乙 += 值乙 * 值乙
	}

	return 点积 / float32(math.Sqrt(float64(模长甲))*math.Sqrt(float64(模长乙)))
}

3.4 Java (JDK 21 引入的 Vector API 实验版)

在 JDK 21+ 中，我们可以利用 Vector API 强迫 JIT 编译器在运行时将代码编译成物理 CPU 的 AVX 向量并行指令。

java 复制代码

import jdk.incubator.vector.FloatVector;
import jdk.incubator.vector.VectorSpecies;

public class 向量计算器_JAVA {
    // 自动适配当前 CPU 支持的最大位宽（如 256 位，同时计算 8 个 float）
    private static final VectorSpecies<Float> 物理位宽 = FloatVector.SPECIES_PREFERRED;

    public static float 计算余弦相似度_JAVA(float[] 向量甲, float[] 向量乙) {
        float 点积 = 0.0f;
        float 模长甲 = 0.0f;
        float 模长乙 = 0.0f;
        
        int 步长 = 物理位宽.length();
        int 循环上限 = 向量甲.length - (向量甲.length % 步长);

        // 1. 批量处理 SIMD 物理运算
        for (int 索引 = 0; 索引 < 循环上限; 索引 += 步长) {
            var 向量块甲 = FloatVector.fromArray(物理位宽, 向量甲, 索引);
            var 向量块乙 = FloatVector.fromArray(物理位宽, 向量乙, 索引);
            
            点积 += 向量块甲.mul(向量块乙).reduceLanes(VectorOperators.ADD);
            模长甲 += 向量块甲.mul(向量块甲).reduceLanes(VectorOperators.ADD);
            模长乙 += 向量块乙.mul(向量块乙).reduceLanes(VectorOperators.ADD);
        }

        // 2. 补齐余下的尾数部分
        for (int 索引 = 循环上限; 索引 < 向量甲.length; 索引++) {
            float 值甲 = 向量甲[索引];
            float 值乙 = 向量乙[索引];
            点积 += 值甲 * 值乙;
            模长甲 += 值甲 * 值甲;
            模长乙 += 值乙 * 值乙;
        }

        return 点积 / (float)(Math.sqrt(模长甲) * Math.sqrt(模长乙));
    }
}

四、避坑指南与编译器调优

4.1 C++ 忘记开启硬件优化参数

⚠️ 性能黑洞 ：在 C++ 测试时，如果不加 -O3 -march=native 编译参数。默认构建出来的二进制包在计算 1000 万次相似度时会耗时 12 秒以上，甚至比 Java 传统循环还要慢。

✅ 解决方案：在构建底层 C/C++ 模块时，切记开启最高级别优化，并告知编译器针对宿主机的 CPU 架构生成特定的 SSE/AVX 汇编。

4.2 Go 语言切片扩容的堆分配逃逸

⚠️ GC 频繁触发 ：在 Go 语言中，如果把大数组在多层函数传递中被隐式转成了 interface{}，或者发生逃逸分析（Escape Analysis）将其分配到了堆上，频繁的内存动态分配会引发严重的 GC 压力。

五、总结

不到 10ms 以下别跟我说优化过。

高性能不是吹出来的，是在寄存器级别实打实跑出来的。

基准测试的数据得出的最终选型建议：

如果你追求极致算力，且没有网络 IO 损耗，选用 C++ 或 Rust。
如果你的业务以快速迭代的 API 业务为主，Java (启用 Vector API) 和 Go 也完全够用，但必须注意降低内存拷贝损耗。

数据已经摆在上面，怎么选显而易见。