JDK-18 外来函数：如何使用具有相同名称但来自不同本机库的多个函数？

Question

假设我加载了一个具有函数get_gg（）的本机库gg3，并且想要加载另一个也具有get_gg（）函数的本机库gg4 - 我如何以“库感知”方式查找一个（例如，在某些情况下使用gg4中的get_gg（），否则使用gg3中的get_gg）？

我尝试了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

所以我怎样才能找到

Answer 1

FWIW，完成这项工作所需的API在19年公开

在此之前，建议是通过绑定dlopen、dlclo和dlsym（或Windows等价物）来手动实现它以加载库并查找符号。

e、 g.在我的Windows计算机上：

public class Main {
    
    static final MethodHandle MH_LoadLibraryA;
    static final MethodHandle MH_FreeLibrary;
    static final MethodHandle MH_GetProcAddress;

    static {
        System.loadLibrary("Kernel32");
        SymbolLookup lookup = SymbolLookup.loaderLookup();
        CLinker linker = CLinker.systemCLinker();
        MH_LoadLibraryA = linker.downcallHandle(
            lookup.lookup("LoadLibraryA").orElseThrow(),
            FunctionDescriptor.of(ADDRESS, ADDRESS));
        MH_FreeLibrary = linker.downcallHandle(
            lookup.lookup("FreeLibrary").orElseThrow(),
            FunctionDescriptor.of(JAVA_INT, ADDRESS));
        MH_GetProcAddress = linker.downcallHandle(
            lookup.lookup("GetProcAddress").orElseThrow(),
            FunctionDescriptor.of(ADDRESS, ADDRESS, ADDRESS));
    }

    static MemoryAddress LoadLibraryA(String name) {
        try (ResourceScope scope = ResourceScope.newConfinedScope()) {
            SegmentAllocator allocator = SegmentAllocator.nativeAllocator(scope);
            return (MemoryAddress) MH_LoadLibraryA.invokeExact((Addressable) allocator.allocateUtf8String(name));
        } catch (Throwable t) {
            throw new RuntimeException(t);
        }
    }

    static boolean FreeLibrary(MemoryAddress handle) {
        try {
            return ((int) MH_FreeLibrary.invokeExact((Addressable) handle)) != 0;
        } catch (Throwable t) {
            throw new RuntimeException(t);
        }
    }

    static MemoryAddress GetProcAddress(MemoryAddress handle, String name) {
        try (ResourceScope scope = ResourceScope.newConfinedScope()) {
            SegmentAllocator allocator = SegmentAllocator.nativeAllocator(scope);
            return (MemoryAddress) MH_GetProcAddress.invokeExact((Addressable) handle, (Addressable) allocator.allocateUtf8String(name));
        } catch (Throwable t) {
            throw new RuntimeException(t);
        }
    }
    
    static SymbolLookup libraryLookup(String libraryName, ResourceScope scope) {
        MemoryAddress handle = LoadLibraryA(libraryName);
        if (handle == MemoryAddress.NULL) {
            throw new IllegalArgumentException("Cannot find library: " + libraryName);
        }
        scope.addCloseAction(() -> FreeLibrary(handle));
        return name -> {
            var addr = GetProcAddress(handle, name);
            return addr == MemoryAddress.NULL ?
                Optional.empty() : Optional.of(NativeSymbol.ofAddress(name, addr, scope));
        };
    }

    public static void main(String[] args) throws Throwable {
        try (ResourceScope scope = ResourceScope.newConfinedScope()) {
            SymbolLookup lookup = libraryLookup("gg", scope);
            MethodHandle handle = CLinker.systemCLinker().downcallHandle(
                lookup.lookup("get_gg").orElseThrow(),
                FunctionDescriptor.of(JAVA_INT));
            int x = (int) handle.invoke();
            System.out.println(x);
        }
    }
}