JDK 18外部函数：如何处理不同原生库中的同名函数？

已加载包含get_gg()函数的原生库gg3，现在需要加载同样包含get_gg()函数的原生库gg4，希望能按库区分调用不同版本的函数（比如特定场景用gg4的get_gg()，其余场景用gg3的）。

尝试过用CLinker.systemCLinker().lookup()，但它只会返回已加载库中第一个找到的符号；发现内部类SystemLookup.libLookup()看似可行但并非公开方法，于是自己实现了类似的加载已加载原生库的方法：

private static SymbolLookup libLookup(Function<NativeLibraries, NativeLibrary> loader) {
        NativeLibrary lib = loader.apply(NativeLibraries.rawNativeLibraries(SystemLookup.class, false));
        return name -> {
            Objects.requireNonNull(name);
            try {
                long addr = lib.lookup(name);
                return addr == 0 ?
                        Optional.empty() :
                        Optional.of(NativeSymbol.ofAddress(name, MemoryAddress.ofLong(addr), ResourceScope.globalScope()));
            } catch (NoSuchMethodException e) {
                return Optional.empty();
            }
        };
    }

但运行时触发错误：

java.lang.UnsatisfiedLinkError: Native Library already loaded in another classloader

需求：如何找到合适的类加载器，或者无需重新加载库就能查找特定库中的符号？

1. 类加载器隔离加载 #

原生库在JVM中只能被一个类加载器加载一次，通过不同类加载器分别加载gg3和gg4，可实现符号隔离：

• 自定义继承ClassLoader的类加载器，用它加载其中一个库（如gg4），原类加载器加载gg3。
• 两个库会被不同类加载器管理，彼此符号不会冲突。

示例代码：

// 自定义隔离类加载器
class IsolatingClassLoader extends ClassLoader {
    public void loadTargetLibrary(String libName) {
        super.loadLibrary(libName);
    }
}

// 使用示例
// 原类加载器加载gg3
System.loadLibrary("gg3");
// 自定义类加载器加载gg4
IsolatingClassLoader isolatedLoader = new IsolatingClassLoader();
isolatedLoader.loadTargetLibrary("gg4");

之后可通过各自类加载器的上下文查找对应库的函数，避免符号冲突。

2. 直接调用系统API操作库句柄 #

无需类加载器隔离，通过JNI调用系统级API（Linux/macOS的dlopen/dlsym，Windows的LoadLibrary/GetProcAddress），直接获取指定库的函数地址：

• 手动加载目标库获取句柄，再查找函数地址，最后绑定到Java方法调用。

示例代码（Linux/macOS环境）：

import java.lang.foreign.*;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;

public class SpecificNativeFuncResolver {
    // 声明调用系统API的native方法
    private static native long dlopen(String libPath, int flags);
    private static native long dlsym(long libHandle, String funcName);
    private static native void dlclose(long libHandle);

    static {
        System.loadLibrary("c"); // 加载C标准库提供系统API
    }

    // 系统API参数常量
    private static final int RTLD_NOW = 0x00002;
    private static final int RTLD_LOCAL = 0x00004;

    public static MethodHandle getTargetFunction(String libPath, String funcName) throws Throwable {
        // 加载目标库
        long libHandle = dlopen(libPath, RTLD_NOW | RTLD_LOCAL);
        if (libHandle == 0) {
            throw new UnsatisfiedLinkError("Failed to load library: " + libPath);
        }

        // 查找函数地址
        long funcAddr = dlsym(libHandle, funcName);
        if (funcAddr == 0) {
            dlclose(libHandle);
            throw new NoSuchMethodError("Function " + funcName + " not found in library");
        }

        // 转换为Java可调用的MethodHandle
        MemoryAddress addr = MemoryAddress.ofLong(funcAddr);
        NativeSymbol funcSymbol = NativeSymbol.ofAddress(funcName, addr, ResourceScope.globalScope());
        // 根据实际函数签名修改MethodType
        return CLinker.systemCLinker().downcallHandle(funcSymbol, MethodType.methodType(void.class));
    }

    public static void main(String[] args) throws Throwable {
        // 获取gg3的get_gg方法句柄
        MethodHandle gg3Func = getTargetFunction("/absolute/path/to/gg3.so", "get_gg");
        // 获取gg4的get_gg方法句柄
        MethodHandle gg4Func = getTargetFunction("/absolute/path/to/gg4.so", "get_gg");

        // 按需调用不同版本函数
        gg3Func.invoke();
        gg4Func.invoke();
    }
}

3. 使用Java 16+的SymbolLookup.libraryLookup #

Java 16及以上版本提供SymbolLookup.libraryLookup方法，可直接获取指定库的符号查找器，无需依赖内部API：

• 先通过System.load加载库（需指定绝对路径），再用libraryLookup获取对应库的查找器，精准查找函数。

示例代码：

import java.lang.foreign.*;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodType;
import java.util.Optional;

public class LibSpecificSymbolLookup {
    public static void main(String[] args) {
        // 加载gg3和gg4（需指定绝对路径）
        System.load("/absolute/path/to/gg3.so");
        System.load("/absolute/path/to/gg4.so");

        // 获取gg3的符号查找器
        SymbolLookup gg3Lookup = SymbolLookup.libraryLookup("gg3", ResourceScope.globalScope());
        // 获取gg4的符号查找器
        SymbolLookup gg4Lookup = SymbolLookup.libraryLookup("gg4", ResourceScope.globalScope());

        // 查找各自的get_gg函数
        Optional<NativeSymbol> gg3GetGg = gg3Lookup.lookup("get_gg");
        Optional<NativeSymbol> gg4GetGg = gg4Lookup.lookup("get_gg");

        // 转换为MethodHandle调用（根据实际函数签名调整MethodType）
        gg3GetGg.ifPresent(symbol -> {
            try {
                MethodHandle mh = CLinker.systemCLinker().downcallHandle(symbol, MethodType.methodType(void.class));
                mh.invoke();
            } catch (Throwable e) {
                e.printStackTrace();
            }
        });

        gg4GetGg.ifPresent(symbol -> {
            try {
                MethodHandle mh = CLinker.systemCLinker().downcallHandle(symbol, MethodType.methodType(void.class));
                mh.invoke();
            } catch (Throwable e) {
                e.printStackTrace();
            }
        });
    }
}

内容的提问来源于stack exchange，提问作者unlimitednzt