关于java:Unsafe那些事

Unsafe 是位于 sun.misc 包下的一个类，次要提供一些用于执行低级别、不平安操作的办法，如间接拜访零碎内存资源、自主治理内存资源等，这些办法在晋升 Java 运行效率、加强 Java 语言底层资源操作能力方面起到了很大的作用。但因为 Unsafe 类使 Java 语言领有了相似 C 语言指针一样操作内存空间的能力，这无疑也减少了程序产生相干指针问题的危险。在程序中适度、不正确应用 Unsafe 类会使得程序出错的概率变大，使得 Java 这种平安的语言变得不再“平安”，因而对 Unsafe 的应用肯定要谨慎。

private static sun.misc.Unsafe getUnsafe() {
        try {return AccessController.doPrivileged(new PrivilegedExceptionAction<Unsafe>() {
                @Override
                public sun.misc.Unsafe run() throws Exception {
                    Class<sun.misc.Unsafe> k = sun.misc.Unsafe.class;
                    for (Field f : k.getDeclaredFields()) {f.setAccessible(true);
                        Object x = f.get(null);
                        if (k.isInstance(x)) {return k.cast(x);
                        }
                    }
                    // The sun.misc.Unsafe field does not exist.
                    throw new Error("unsafe is null");
                }
            });
        } catch (Throwable e) {throw new Error("get unsafe failed", e);
        }
    }

allocateMemory/freeMemory，调配、开释堆外内存 DirectMemory（和 c /cpp 中的 malloc 一样）
CAS 操作
copyMemory
defineClass(without security checks)
get/put address 应用堆外内存地址进行数据的读写操作
get/put volatile 应用堆外内存地址进行数据的读写操作 – volatile 版本
loadFence/storeFence/fullFence 禁止指令重排序
park/unpark 阻塞 / 解除阻塞线程

unsafe 中，有两个对于数组的办法：

public native int arrayBaseOffset(Class<?> arrayClass);
public native int arrayIndexScale(Class<?> arrayClass);

首先，在 Java 中，数组也是对象

In the Java programming language, arrays are objects (§4.3.1), are dynamically created, and may be assigned to variables of type Object (§4.3.2). All methods of class Object may be invoked on an array.
https://docs.oracle.com/javase/specs/jls/se7/html/jls-10.html

那么既然是对象，就会有 object header，占用一部分空间，那么了解数组的 base offset 也就不难了

比方上面的一段 JOL 输入，实际上对象的属性数据是从 OFFSET 16 的地位开始的，0-12 的空间被 header 所占用

HotSpot 64-bit VM, COOPS, 8-byte alignment

lambda.Book object internals:
 OFFSET  SIZE           TYPE DESCRIPTION                               VALUE
      0    12                (object header)                           N/A
     12     4            int Book.sales                                N/A
     16     4         String Book.title                                N/A
     20     4      LocalDate Book.publishTime                          N/A
     24     4         String Book.author                               N/A
     28     4   List<String> Book.tags                                 N/A
Instance size: 32 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

那么如果要拜访对象的属性数据，须要基于基地址（base address）进行偏移，基地址 + 根底偏移（base offset）+ 属性偏移（field offset）才是数据的内存地址（逻辑），那么 title 属性的内存地址实际上就是：

book(instance).title field address = book object base address + base offset + title field offset

数组在 Java 里能够视为一种非凡的对象，无论什么类型的数组，他们在内存中都会有一分根底偏移的空间，和 object header 相似

通过测试，64 位的 JVM 数组类型的根底偏移都是 16（测试后果在不同 JVM 下可能会有所区别）
原始类型的根底偏移都是 12（测试后果在不同 JVM 下可能会有所区别）
能够应用 JOL 工具查看原始类型包装类的 offset，比方 int 就看 Integer 的，尽管 jdk 没有提供函数，然而通过 JOL 也是能够获取的，jvm 类型和对其形式匹配即可
**

就是指数组中每个元素所占用的空间大小，比方 int[] scale 就是 4，long[] scale 就是 8，object[] scale 就是 4（指针大小）

有了这个 offset，就能够对数组进行 copyMemory 操作了

public native void copyMemory(Object srcBase, long srcOffset,
                                  Object destBase, long destOffset,
                                  long bytes);

在应用 copyMemory 操作时，须要传入对象及对象的 base offset，对于数组来说，offset 就是下面介绍的 offset，比方当初将一个数组中的数据拷贝至 DirectBuffer

byte[] byte = new byte[4096];
unsafe.copyMemory(byte,ARRAY_BYTE_BASE_OFFSET,null,directAddr,4096);

之所以应用 unsafe 而不是 ByteBuffer 的办法来操作 DirectBuffer，是因为 ByteBuffer 不够灵便。

比方我想把一个 byte[] 拷贝至 DirectBuffer 的某个地位中，就没有相应的办法；只能先设置 position，而后再 put(byte[], int, int)，十分麻烦，而且并发拜访时 position(long) 和 put 也是个非原子性操作

然而用 unsafe 来操作的话就很轻松了，间接 copyMemory，间接指定 address + offset 就行

unsafe.copyMemory(byte,ARRAY_BYTE_BASE_OFFSET,null,directAddr,4096);

srcBase 原数据对象，能够是对象、数组（对象），也能够是 Null（为 Null 时必须指定 offset，offset 就是 address）
srcOffset 原数据对象的 base offset，如果 srcBase 为空则此项为 address
destBase 指标数据对象，规定同 src
destOffset 指标数据对象的 base offset，规定同 src
bytes 要拷贝的数据大小（字节单位）

通过 copyMemory 办法，能够做各种拷贝操作：

对象（个别是数组）拷贝到指定堆外内存地址

long l = unsafe.allocateMemory(1);
data2[0] = 5;
// 指标是 memory address，destBase 为 null，destOffset 为 address
unsafe.copyMemory(data2,16,null,l,1);

将对象拷贝到对象

byte[] data1 = new byte[1];
data1[0] = 9;

byte[] data2 = new byte[1];
unsafe.copyMemory(data1,16,data2,16,1);

将堆外内存地址的数据拷贝到堆内（个别是数组）

byte[] data2 = new byte[1];

long l = unsafe.allocateMemory(1);
unsafe.putByte(l, (byte) 2);
// 源数据是 memory address，srcBase 为 null，srcOffset 为 address
unsafe.copyMemory(null,l,data2,16,1);

堆外内存地址相互拷贝

long l = unsafe.allocateMemory(1);
long l2 = unsafe.allocateMemory(1);
unsafe.putByte(l, (byte) 2);
// 源数据是 memory address，srcBase 为 null，srcOffset 为 address
// 指标是 memory address，destBase 为 null，destOffset 为 address
unsafe.copyMemory(null,l,null,l2,1);

 禁用 JIT 后果：Benchmark                           Mode  Cnt        Score   Error   Units
ObjectFieldSetBenchmark.manualSet  thrpt    2  8646455.472          ops/ns
ObjectFieldSetBenchmark.unsafeSet  thrpt    2  7901066.170          ops/ns

 启用 JIT 后果：Benchmark                           Mode  Cnt          Score   Error   Units
ObjectFieldSetBenchmark.manualSet  thrpt    2  477232013.545          ops/ns
ObjectFieldSetBenchmark.unsafeSet  thrpt    2  499135982.962          ops/ns

论断，简直没区别

个别应用 DirectBuffer 时，须要配合 Unsafe 来应用，因为 DirectBuffer 的内存是调配在 JVM Heap 之外的，属于 C Heap，所以须要用间接操作内存地址（逻辑），和 C 里 malloc 之后的操作形式一样 **

关于java:Unsafe那些事

简介

获取 Unsafe 实例

Unsafe 性能列表

Unsafe 的数组操作

base offset 含意

index scale 含意

array copy to direct memory

copyMemory(Object srcBase, long srcOffset, Object destBase, long destOffset, long bytes)

Benchmark

sun.misc.Unsafe#putInt(java.lang.Object, long, int) & object field manual set

什么时候用 Unsafe