Go 可通过 -buildmode=c-shared 导出 C 兼容函数，但原生不支持直接传递二维切片；需将其降维为一维连续内存块，并配合 GoSlice 结构体在 C/JNA 侧手动重建二维逻辑。本文详解安全、可移植的实现方案。
go 可通过 `-buildmode=c-shared` 导出 c 兼容函数，但原生不支持直接传递二维切片；需将其降维为一维连续内存块，并配合 `goslice` 结构体在 c/jna 侧手动重建二维逻辑。本文详解安全、可移植的实现方案。
在 Go 中导出供 Java（JNA）或 C 直接调用的共享库时，核心限制在于：Go 的 [][]T（二维切片）不是 C 兼容类型——它由指针数组（*[]T）构成，内存不连续，且包含 Go 运行时元信息，无法跨语言边界直接传递。正确做法是将二维数据“展平”为一维 []T，并通过显式维度参数（如 rows, cols）传递结构信息，由调用方负责解析。
✅ 推荐实践：展平 + 显式维度 + 安全内存管理
以下以 float64 类型的 m×n 矩阵加法为例，展示完整端到端流程：
1. Go 端：导出展平接口（libmatrix.so）
package main
import (
"C"
"unsafe"
)
//export MatrixAdd
func MatrixAdd(
aData *C.double, aRows, aCols C.int,
bData *C.double, bRows, bCols C.int,
outData *C.double, outRows, outCols C.int,
) C.int {
// 验证维度一致性（关键！）
if aRows != bRows || aCols != bCols || aRows != outRows || aCols != outCols {
return -1 // 错误码：维度不匹配
}
n := int(aRows * aCols)
for i := 0; i < n; i++ {
outData[i] = aData[i] + bData[i]
}
return 0 // 成功
}
//export MatrixMul
func MatrixMul(
aData *C.double, aRows, aCols C.int,
bData *C.double, bRows, bCols C.int,
outData *C.double, outRows, outCols C.int,
) C.int {
if aCols != bRows || aRows != outRows || bCols != outCols {
return -1
}
for i := 0; i < int(aRows); i++ {
for j := 0; j < int(bCols); j++ {
sum := 0.0
for k := 0; k < int(aCols); k++ {
sum += aData[i*int(aCols)+k] * bData[k*int(bCols)+j]
}
outData[i*int(outCols)+j] = sum
}
}
return 0
}
// 必须保留此空主函数，否则 c-shared 构建失败
func main() {}编译命令：
go build -buildmode=c-shared -o libmatrix.so .
⚠️ 注意：
- 所有参数均为 C 原生类型（*C.double, C.int），无 Go 切片或结构体；
- aData, bData, outData 指向调用方分配的连续内存（Java/JNA 或 C 侧负责 malloc/free）；
- 返回 C.int 作为错误码（0=成功），符合 C 习惯；
- Go 不负责内存分配/释放，避免跨语言内存管理冲突。
2. C 端调用示例（安全、可验证）
#include <stdio.h>
#include <stdlib.h>
#include "libmatrix.h" // 对应生成的头文件（或手动声明）
int main() {
const int m = 2, n = 3;
double a[6] = {1,2,3,4,5,6};
double b[6] = {7,8,9,10,11,12};
double out[6];
int ret = MatrixAdd(a, m, n, b, m, n, out, m, n);
if (ret == 0) {
printf("Result: [");
for (int i = 0; i < 6; i++) printf("%.0f ", out[i]);
printf("]\n"); // 输出: [8 10 12 14 16 18]
}
return ret;
}3. Java/JNA 端（使用 NativeLibrary + Pointer）
import com.sun.jna.*;
import com.sun.jna.ptr.*;
public interface MatrixLib extends Library {
MatrixLib INSTANCE = Native.load("matrix", MatrixLib.class);
// 对应 Go 函数签名：MatrixAdd(double*, int, int, ...)
int MatrixAdd(DoubleByReference aData, int aRows, int aCols,
DoubleByReference bData, int bRows, int bCols,
DoubleByReference outData, int outRows, int outCols);
// 更推荐：使用 Pointer + getDoubleArray()（更灵活）
int MatrixAdd(Pointer aPtr, int aRows, int aCols,
Pointer bPtr, int bRows, int bCols,
Pointer outPtr, int outRows, int outCols);
}
// 使用示例
public class MatrixTest {
public static void main(String[] args) {
int m = 2, n = 3;
double[] a = {1,2,3,4,5,6};
double[] b = {7,8,9,10,11,12};
double[] out = new double[6];
Pointer aPtr = new Memory(a.length * 8); // 8 bytes per double
Pointer bPtr = new Memory(b.length * 8);
Pointer outPtr = new Memory(out.length * 8);
aPtr.setDoubleArray(0, a, 0, a.length);
bPtr.setDoubleArray(0, b, 0, b.length);
int ret = MatrixLib.INSTANCE.MatrixAdd(
aPtr, m, n, bPtr, m, n, outPtr, m, n
);
if (ret == 0) {
outPtr.getDoubleArray(0, out, 0, out.length);
System.out.println("Result: " + Arrays.toString(out));
}
}
}? 关键要点：
- Java 侧完全控制内存生命周期：Memory 分配 → setDoubleArray() 写入 → getDoubleArray() 读取 → 自动 GC（或显式 free()）；
- 绝不返回 Go 分配的内存给 Java（如原始答案中 malloc + string 传递方式存在严重泄漏与悬垂指针风险，已弃用）；
- 维度参数（rows, cols）必须显式传递，这是重建二维语义的唯一可靠依据。
❌ 不推荐的陷阱方案（原始答案中的问题）
原始回答中尝试用 unsafe.Pointer(C.malloc()) 分配内存并构造 string 返回，存在多重风险：
- Java/JNA 无法安全释放 Go 分配的 malloc 内存（free() 调用可能跨 libc 实现不兼容）；
- reflect.StringHeader 操作破坏 Go 内存安全模型，在未来 Go 版本中可能失效；
- [][]T 无法直接映射为 GoSlice 数组（GoSlice 本身是 C 结构体，但二维切片需双重指针，C 侧难以安全解包）。
✅ 总结：最佳实践清单
| 项目 | 推荐做法 |
|---|---|
| 数据传递 | 展平为 []T → 传 *T + rows/cols 参数 |
| 内存管理 | 调用方（C/Java）分配 & 释放，Go 仅读写，不 malloc/free |
| 错误处理 | 返回 int 错误码（非 panic），调用方检查 |
| 类型安全 | 使用 C.double, C.int 等明确 C 类型，避免 GoSlice 跨语言传递 |
| 构建 | go build -buildmode=c-shared -o libxxx.so，生成 .so + .h |
| Java 适配 | JNA Pointer + set/getXXXArray()，配合 Memory 管理 |
遵循此模式，你不仅能安全暴露矩阵运算，还可扩展至任意高维数值计算场景（如图像处理、机器学习推理），同时确保 C 和 Java 两端的稳定性与可维护性。
