Java直接读取指定内存偏移字节及JNI同进程内存共享技术问询

嘿，针对你在JNI场景下想要实现C++和Java进程内内存共享、避开文件IO开销的需求，这里有几个高效的解决方案，完全匹配你的需求：

这是最推荐的方案，完全绕开文件操作，实现C++与Java的原生内存直接共享，且支持Java端灵活读取指定偏移的字节数据。

实现逻辑 #

1. C++侧分配匿名共享内存（用mmap的MAP_ANONYMOUS标记，仅进程内可用，无文件开销），将远程数据源的数据写入这块内存。
2. 通过JNI的NewDirectByteBuffer方法，创建一个指向该原生内存块的DirectByteBuffer对象并返回给Java。
3. Java端通过position()设置偏移量，结合slice()或get()方法读取指定区域的字节数据。

C++代码示例

#include <sys/mman.h>
#include <cstring>

#define BUFFER_SIZE 4096 // 根据实际需求定义内存大小

// 全局存储共享内存地址（也可封装到类中）
void* g_shared_mem = nullptr;

// JNI方法：返回指向共享内存的DirectByteBuffer
JNIEXPORT jobject JNICALL Java_com_example_MyNativeBridge_getSharedByteBuffer(JNIEnv* env, jobject obj) {
    // 初始化匿名共享内存（仅第一次调用时分配）
    if (g_shared_mem == nullptr) {
        g_shared_mem = mmap(nullptr, BUFFER_SIZE, PROT_READ | PROT_WRITE, 
                            MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
        if (g_shared_mem == MAP_FAILED) {
            return nullptr; // 内存分配失败处理
        }
    }

    // 模拟从远程数据源写入数据到共享内存
    const char* remote_data = "来自远程数据源的测试数据";
    memcpy(g_shared_mem, remote_data, strlen(remote_data));

    // 创建DirectByteBuffer并返回
    return env->NewDirectByteBuffer(g_shared_mem, BUFFER_SIZE);
}

Java代码示例

import java.nio.ByteBuffer;

public class MyNativeBridge {
    // 加载JNI库
    static {
        System.loadLibrary("native-lib");
    }

    private native ByteBuffer getSharedByteBuffer();

    public void readDataAtOffset(int offset, int length) {
        ByteBuffer buffer = getSharedByteBuffer();
        if (buffer == null) {
            throw new RuntimeException("共享内存初始化失败");
        }

        // 校验偏移和长度合法性
        if (offset < 0 || offset + length > buffer.capacity()) {
            throw new IndexOutOfBoundsException("非法的偏移或长度");
        }

        // 设置读取偏移，截取指定区域
        buffer.position(offset);
        ByteBuffer targetSlice = buffer.slice();
        targetSlice.limit(length);

        // 将数据读取到Java字节数组
        byte[] result = new byte[length];
        targetSlice.get(result);

        // 处理读取到的数据
        System.out.println("读取到的内容：" + new String(result));
    }
}

如果你的业务场景需要基于Java侧已分配的字节数组进行操作，可以让C++直接写入数组的指定偏移位置，无需额外共享内存块。

实现逻辑 #

1. Java侧分配字节数组，调用JNI方法传入数组、偏移量和要写入的长度。
2. C++通过JNI的GetPrimitiveArrayCritical锁定数组（避免GC移动内存），直接向数组的指定偏移位置写入数据。
3. 完成写入后调用ReleasePrimitiveArrayCritical解锁数组。

C++代码示例

JNIEXPORT void JNICALL Java_com_example_MyNativeBridge_writeToByteArray(JNIEnv* env, jobject obj,
                                                                        jbyteArray byte_arr, jint offset, jint length) {
    // 获取字节数组的原生指针并锁定
    jbyte* arr_ptr = env->GetPrimitiveArrayCritical(byte_arr, nullptr);
    if (arr_ptr == nullptr) {
        return; // 内存不足或数组无效处理
    }

    // 模拟从远程数据源读取数据，写入数组的指定偏移位置
    const char* remote_data = "写入到指定偏移的测试数据";
    memcpy(arr_ptr + offset, remote_data, length);

    // 解锁数组，允许GC操作
    env->ReleasePrimitiveArrayCritical(byte_arr, arr_ptr, 0);
}

Java代码示例

import java.util.Arrays;

public class MyNativeBridge {
    static {
        System.loadLibrary("native-lib");
    }

    private native void writeToByteArray(byte[] byteArr, int offset, int length);

    public void testOffsetWrite() {
        byte[] buffer = new byte[1024];
        // 让C++写入偏移为100、长度为20的数据
        writeToByteArray(buffer, 100, 20);
        // 读取指定偏移的内容
        byte[] targetData = Arrays.copyOfRange(buffer, 100, 120);
        System.out.println("指定偏移的内容：" + new String(targetData));
    }
}

如果你需要极致灵活的内存操作，可以使用Java的Unsafe类直接访问C++分配的原生内存地址，但该类属于非公开API，存在内存泄漏、越界访问等风险，仅在特殊场景下使用。

核心逻辑 #

C++将共享内存的地址和长度传递给Java，Java通过Unsafe的getByte()、getInt()等方法直接读取指定偏移的内存数据。

方案总结 #

• 优先选择方案1：零拷贝、性能最高，完全满足你读取指定偏移字节数组、进程内内存共享的需求，且API安全稳定。
• 若业务依赖Java侧已有的字节数组，可选择方案2，操作简单且无额外内存开销。

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