【环境】

Linux环境

在这里插入图片描述

约定: 所有的测试文件都放在2022-3-15目录下

【1】

将 $JAVA_HOME/include/jni.h 和 $JAVA_HOME/include/linux/jni_md.h 两个文件拷贝到2022-3-15目录下

在这里插入图片描述

【2】
创建JNINativeMemory.java文件

// JNINativeMemory.java
public class JNINativeMemory {

    public native void allocateMemory();

}

在这里插入图片描述

执行命令生成.h文件
javac -h . JNINativeMemory.java

在这里插入图片描述

修改生成的JNINativeMemory.h文件内容, 将<jni.h>改成"jni.h"

在这里插入图片描述

2】

创建JNINativeMemory.c文件

#include "jni.h"
#include "JNINativeMemory.h" // 我们自己的头文件
#include <stdlib.h>
#include <stdio.h>

// 这个方法的名称从JNINativeMemory.h拷贝过来, 方法名称不能错哦
JNIEXPORT void JNICALL Java_JNINativeMemory_allocateMemory(JNIEnv *env, jobject j) {
    // 申请内存
    void *ptr = malloc(1000);
    // 打印内存地址
    printf("> %p\n", ptr);
}

目前的目录结构图如下

在这里插入图片描述

【3】制作动态库

gcc -fpic -c JNINativeMemory.c

以上命令会生成.o文件

在这里插入图片描述

gcc -shared JNINativeMemory.o -o libjninativememory.so

以上命令会生成.so文件

在这里插入图片描述

【4】

通过System.getProperty("java.library.path")查看库所在的目录, 我自己本机电脑是

/usr/java/packages/lib/amd64:/usr/lib64:/lib64:/lib:/usr/lib

于是我把上一步生成的libjninativememory.so 拷贝到/usr/lib目录下

在这里插入图片描述

【5】

编写测试类

public class Test {

    static {
        System.loadLibrary("jninativememory");
    }

    public static void main(String[] args) throws Exception {
        JNINativeMemory caller = new JNINativeMemory();
        caller.allocateMemory();
        System.in.read();
    }

}

System.loadLibrary("jninativememory") 中的jninativememory必须与上一步生成的libjninativememory.so保持一致, 这里说的一致, 是libjninativememory.so去掉前面的lib三个字符, 去掉.so之后的名称.

编译&执行

在这里插入图片描述

成功打印地址

通过命令more /proc/3934/maps 查看进程的内存布局, 也可以看到加载了之前制作的动态库libjninativememory.so

在这里插入图片描述

之所以要通过调用C库的malloc函数申请内存, 主要就是要观察在Java中, 堆外内存/直接内存的申请方式, 以及如何被管理的. 在Java中可以通过使用ByteBuffer.allocateDirect() 和 unsafe.allocateMemory() 以及本文介绍的通过JNI申请内存, 这三种方式的区别是什么呢? 下文再说

源码位置

接下来我们把上面的目录2022-3-15拷贝一下, 变成2022-3-15.2目录

同时添加2个jar包

在这里插入图片描述

对应的依赖如下

<dependency>
    <groupId>org.jctools</groupId>
    <artifactId>jctools-core</artifactId>
    <version>2.1.2</version>
</dependency>

<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.9</version>
</dependency>

接下来我们通过Unsafe.allocateMemory 和 C语言的malloc 分别申请32MB的内存, 看看有啥区别

import org.jctools.util.UnsafeAccess;
import sun.misc.Unsafe;

public class Test {

    static {
        System.loadLibrary("jninativememory");
    }

    public static void main(String[] args) throws Exception {
        JNINativeMemory caller = new JNINativeMemory();
        caller.allocateMemory();

        Unsafe unsafe = UnsafeAccess.UNSAFE;
        // 32MB
        long addr = unsafe.allocateMemory(32 * 1024 * 1024);
        System.out.println("Java 申请:\t 0x" + Long.toHexString(addr));


        System.in.read();
    }

}

#include "jni.h"
#include "JNINativeMemory.h"
#include <stdlib.h>
#include <stdio.h>

JNIEXPORT void JNICALL Java_JNINativeMemory_allocateMemory(JNIEnv *env, jobject j) {
    // 32MB
    void *ptr = malloc(32 * 1024 * 1024);
    printf("C'malloc 申请 %p\n", ptr);
}

重新生成.so动态库并拷贝到/usr/lib/目录下

这里需要注意的是, 由于Java代码中依赖了外部jar包, 所以在编译的时候有点区别, 编译指定classpath

在这里插入图片描述

执行

在这里插入图片描述

在这里插入图片描述

0x7f6f2dfff010 在区间 7f6f2dfff000-7f6f30000000范围内

0x7f6f5149f010 在区间 7f6f5149f000-7f6f534a0000范围内

而且我们获取到的内存地址比区间开始偏移了0x10, 为什么我们没有拿到区间开始的地址呢? 其实这不是偶然, 也是底层设计如此.

我们再改变一下, 不使用malloc分配内存, 而是使用mmap分配内存.

#include "jni.h"
#include "JNINativeMemory.h"
#include <stdlib.h>
#include <stdio.h>
#include <sys/mman.h>

JNIEXPORT void JNICALL Java_JNINativeMemory_allocateMemory(JNIEnv *env, jobject j) {
    // 32MB = 33554432

    void *ptr = mmap(NULL, 33554432, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
    printf("C'mmap 申请 %p\n", ptr);


    //void *ptr = malloc(32 * 1024 * 1024);
    //printf("C'malloc 申请 %p\n", ptr);
}

重新生成.so动态库并拷贝到/usr/lib/目录下

重新执行测试类, 结果如下

在这里插入图片描述

使用more /proc/4341/maps查看进程的内存布局

在这里插入图片描述

两个区间都是32MB, 与我们申请的吻合

哎，在这里我们看到使用mmap申请的内存, 我们拿到的起始地址就是maps中显示的地址, 是吻合的. 而Java方式拿到的地址, 还是一样, 偏差了0x10

简单说, malloc底层调用mmap系统函数申请内存(还有一种是brk系统函数), 只是malloc又对从操作系统拿到的内存做了手脚, 之所以做手脚是为了合理管理内存.

暂时说到这里

源码地址