概述

Unsafe 是 sun.misc 包下的一个类，主要提供一些用于执行低级别：
11. Unsafe - 图1

理解对象中的偏移地址

在说明 Unsafe API 之前，我们先来理解什么是 对象中的偏移地址。

对象在堆中基本内存结构

作为一个 Javaer 都知道对象是存储在堆中的，可是在堆中也肯定由某种数据结构来表示。下图就是 Java 对象在堆中的基本内存结构:
image.png
Java 对象在堆中的结构可大致分为三部分，分别是

  • 对象头。
  • 对象/数组实际数据。
  • 对齐填充。

对于 64 位计算机而言，对象头总共占用 16 字节空间。而对于 32 位计算机，对象头总共占用 8 字节。

Unsafe API

  1. // peek 和 poke 操作。这部分是适用于Java堆的对象，并不适用于打包数组元素上。
  2. // They will not work on elements of packed arrays.
  3. // Java 基本数据类型: byte、short、int、long、float、double、boolean、char
  4. /**
  5.  * 从给定的Java变量中获取一个值。更具体的说，从给定对象o中以给定偏移量或
  6.  * （如果o为空）从数值为给定偏移量的内存地址中获取字段或数组元素。
  7.  *
  8.  * 除非满足以下情况之一，否则结果将会是不确定的:
  9.  * ① 偏移量offset是从某个Java字段的objectFieldOffset获得的，而o所引用的对象是与该字段的类兼容的类。
  10.  * ② 偏移量offset和对象引用o（null或非null）分别通过 staticFieldOffset 和 staticFieldBase 从某些
  11.  *    Java 字段的反射Field表示中获得的。
  12.  * ③ 假如o引用的对象是数组，偏移量是公式B+N*S所返回的整数，表示第N个元素偏移量。
  13.  *    B: 表示arrayBaseOffset()函数求得的值。
  14.  *    N: 数组的有效索引。
  15.  *    S: 表示arrayIndexScale()函数求得的值。表示某个数据类型占用多少字节。比如 arrayIndexScale(int[].class)=4。
  16.  *
  17.  * 如果以上三种情况有一个成立，则该函数调用会执行正确的语义: 该调用引用特定的Java变量（字段或数组元素）。
  18.  * 但是，如果该变量实际上并非由对应函数所返回，则结果将是不确定的。
  19.  * 
  20.  * 由于此方法通过两个参数引用一个变量，因此它实际上为 Java 变量提供了一个「双寄存器寻址模式」。
  21.  * 当参数o==null时，此方法将其偏移量用作「绝对地址」。与 getInt(long address) 函数相同，它为非 java
  22.  * 变量提供单寄存器寻址模式。然而，由于 Java 变量在内存中的布局可能与非Java对象不同，
  23.  * 程序员不应假定这两个寻址模式永远是等效的。
  24.  * 另外，不能将双寄存器寻址模式的偏移量和单寄存器寻址模式中使用的「长度」混淆。
  25.  *
  26.  * @param o        驻留在Java堆中的对象
  27.  * @param offset   如果o != null，表示驻留在Java堆中的对象的位置。
  28.  *                 如果o == null，表示绝对地址
  29.  */
  30. public native int getInt(Object o, long offset);
  31. /**
  32.  * 将值存储到给定的 Java 变量中。
  33.  * 前两个参数可以完全按照 getInt(Object, long) 来理解，表示引用特定的Java变量（字段或数组元素）。
  34.  * 将给定的值存储在该变量中。
  35.  * 变量必须与方法参数x的类型相同。
  36.  */
  37. public native void putInt(Object o, long offset, int x);
  39. public native boolean getBoolean(Object o, long offset);
  40. public native void    putBoolean(Object o, long offset, boolean x);
  42. public native byte    getByte(Object o, long offset);
  43. public native void    putByte(Object o, long offset, byte x);
  45. public native short   getShort(Object o, long offset);
  46. public native void    putShort(Object o, long offset, short x);
  48. public native char    getChar(Object o, long offset);
  49. public native void    putChar(Object o, long offset, char x);
  52. public native long    getLong(Object o, long offset);
  53. public native void    putLong(Object o, long offset, long x);
  55. public native float   getFloat(Object o, long offset);
  56. public native void    putFloat(Object o, long offset, float x);
  58. public native double  getDouble(Object o, long offset);
  59. public native void    putDouble(Object o, long offset, double x);
  61. /**
  62.  * 从特定位置获取一个对象
  63.  */
  64. public native Object getObject(Object o, long offset)
  65. /**
  66.  * 除非o==null或与参数x字段类型匹配，否则结果将是不确定的。
  67.  * If the reference o is non-null, 
  68.  * car marks or other store barriers for that object (if the VM requires them) are updated.
  69.  */
  70. public native void putObject(Object o, long offset, Object x);
  75. // 下面这些方法处理在C堆中的值
  76. /**
  77.  * 从给定的内存地址中获取一个值。 
  78.  * 如果地址为零，或未指向从allocateMemory获取的块，则结果不确定。
  79.  */
  80. public native byte    getByte(long address);
  81. /**
  82.  * 将值存储到给定的内存地址中。 
  83.  * 如果地址为零，或未指向从allocateMemory获取的块，则结果不确定。
  84.  */
  85. public native void    putByte(long address, byte x);
  87. public native short   getShort(long address);
  88. public native void    putShort(long address, short x);
  90. public native char    getChar(long address);
  91. public native void    putChar(long address, char x);
  93. public native int     getInt(long address);
  94. public native void    putInt(long address, int x);
  96. public native long    getLong(long address);
  97. public native void    putLong(long address, long x);
  99. public native float   getFloat(long address);
  100. public native void    putFloat(long address, float x);
  102. public native double  getDouble(long address);
  103. public native void    putDouble(long address, double x);
  105. /**
  106.  * 从给定的内存地址中获取本地指针。如果地址为0，或未指向从 allocateMemory 获取的内存块，将导致结果不确定。
  107.  */
  108. public native long getAddress(long address);
  109. /**
  110.  * 存储一个本地指针到目标内存地址。如果地址为0，或未指向从 allocateMemory 获取的内存块，将导致结果不确定。
  111.  * 实际写入的字节数是由 addressSize() 决定的。
  112.  */
  113. public native void putAddress(long address, long x);
  120. // 包装C语言中的malloc、realloc、free函数
  121. /**
  122.  * 分配给定大小的新本地内存块（以字节为单位）。 
  123.  * 存储器的内容未初始化，所以当使用此函数进行内存分配，需要对该内存块进行初始化设置。
  124.  * 与freeMemory() 成对出现，否则只管分配不管释放最终会导致堆外内存用尽，程序报OOM异常。
  125.  * 也可以通过 reallocateMemory(cap) 对已分配的内存块增大或缩小为 cap 大小。
  126.  */
  127. public native long allocateMemory(long bytes);
  129. /**
  130.  * 调整本地内存块的大小。当超过旧块大小的新块内容未初始化，通常是垃圾数据。
  131.  * 结果指针对对齐所有值类型。
  132.  * 如果参数 address == null，在这种情况下还会继续执行内存分配
  133.  */
  134. public native long allocateMemory(long bytes);
  136. /**
  137.  * 将给定内存块中的所有字节设置为一个固定值（通常为0）。
  138.  * 这个函数通常用来做初始化用的。
  139.  * 此方法通过两个参数确定块的基地址。因此，实际上提供了一个「双寄存器模式」。像 getInt(Object, long) 中所讨论的那样。
  140.  * 当参数o==null时，偏移量offset表示的是本地内存的绝对地址。
  141.  * 存储以连贯的（原子的）单位表示，其大小由地址和长度参数确定。
  142.  * 如果有效地址和长度可以被8整除，则当前内存块表示「long」类型数据。
  143.  * 如果有效地址和长度可以被4整除，则当前内存块表示「int」类型数据。
  144.  * 如果有效地址和长度可以被2整除，则当前内存场合表示「short」类型数据。
  145.  */
  146. public native void setMemory(Object o, long offset, long bytes, byte value);
  147. public void setMemory(long address, long bytes, byte value) {
  148.     setMemory(null, address, bytes, value);
  149. }
  151. /**
  152.  * 将给定内存块中的所有字节设置为另一个块的副本。
  153.  * 此方法通过两个参数确定每个内存块的基地址，因此，实际上提供了一个「双寄存器模式」。和 getInt(Object, long) 中所讨论的那样。
  154.  * 存储以连贯的（原子的）单位表示，其大小由地址和长度参数确定。
  155.  * 如果有效地址和长度可以被8整除，则当前内存块表示「long」类型数据。
  156.  * 如果有效地址和长度可以被4整除，则当前内存块表示「int」类型数据。
  157.  * 如果有效地址和长度可以被2整除，则当前内存场合表示「short」类型数据。
  158.  * @param srcBase        源对象
  159.  * @param srcOffset      源对象的偏移量
  160.  * @param destBase       目标对象
  161.  * @param destOffset     目标对象的偏移量
  162.  * @param bytes          拷贝长度
  163.  */
  164. public native void copyMemory(Object srcBase, long srcOffset,
  165.                               Object destBase, long destOffset,
  166.                               long bytes);
  167. public void copyMemory(long srcAddress, long destAddress, long bytes) {
  168.     copyMemory(null, srcAddress, null, destAddress, bytes);
  169. }
  171. /**
  172.  * 将所有元素从一个内存复制到另一个内存块。
  173.  *「unconditionally」 byte swapping the elements on the fly.
  174.  */
  175. private native void copySwapMemory0(Object srcBase, long srcOffset,
  176.                                     Object destBase, long destOffset,
  177.                                     long bytes, long elemSize);
  179. /**
  180.  * 释放由allocatemory、reallocatemory所分配的内存块。
  181.  */
  182. public native void freeMemory(long address);
  189. // 随机查询
  191. // 这个常量不同于 staticFieldOffset, objectFieldOffset 或 arrayBaseOffset 返回的所有结果
  192. public static final int INVALID_FIELD_OFFSET   = -1;
  194. /**
  195.  * 获取给定字段在其类的存储分配中的位置。不要期望对这个偏移量执行任何类型的算术运算。
  196.  * 它只是一个传递给不安全堆内存访问器的cookie。
  197.  * 任何给定的字段将始终具有相同的偏移量和基数，同一类中任何两个不同的字段都不会具有相同的偏移量和基数。
  198.  */
  199. public native long staticFieldOffset(Field f);
  201. /**
  202.  * 和 staticFieldBase 一起获取静态字段的位置。
  203.  */
  204. public native long objectFieldOffset(Field f);
  205.     public native Object staticFieldBase(Field f);
  207. /**
  208.  * 检测给定的类是否需要初始化。这通常需要与获取类的静态字段基一起使用。
  209.  * @return false only if a call to {@code ensureClassInitialized} would have no effect
  210.  */
  211. public native boolean shouldBeInitialized(Class<?> c);
  213. /**
  214.  * 确保给定的类已经初始化。这通常需要与获取类的静态字段基一起使用。
  215.  */
  216. public native void ensureClassInitialized(Class<?> c);
  218. /**
  219.  * 获取给定数组类型的存储分配中用于寻址元素的缩放比例因子。
  220.  * 通常"narrow"类型的数组不能使用比如 getByte() 获取
  221.  */
  222. public native int arrayBaseOffset(Class<?> arrayClass);
  223. public static final int ARRAY_BOOLEAN_BASE_OFFSET = theUnsafe.arrayBaseOffset(boolean[].class);
  224. public static final int ARRAY_BYTE_BASE_OFFSET = theUnsafe.arrayBaseOffset(byte[].class);
  225. public static final int ARRAY_SHORT_BASE_OFFSET = theUnsafe.arrayBaseOffset(short[].class);
  226. public static final int ARRAY_CHAR_BASE_OFFSET = theUnsafe.arrayBaseOffset(char[].class);
  227. public static final int ARRAY_INT_BASE_OFFSET = theUnsafe.arrayBaseOffset(int[].class);
  228. public static final int ARRAY_LONG_BASE_OFFSET = theUnsafe.arrayBaseOffset(long[].class);
  229. public static final int ARRAY_FLOAT_BASE_OFFSET = theUnsafe.arrayBaseOffset(float[].class);
  230. public static final int ARRAY_DOUBLE_BASE_OFFSET = theUnsafe.arrayBaseOffset(double[].class);
  231. public static final int ARRAY_OBJECT_BASE_OFFSET = = theUnsafe.arrayBaseOffset(Object[].class);
  234. /**
  235.  * 获取给定数组类的存储分配中用于寻址元素的比例因子
  236.  */
  237. public native int arrayIndexScale(Class<?> arrayClass);
  238. public static final int ARRAY_BOOLEAN_INDEX_SCALE = theUnsafe.arrayIndexScale(boolean[].class);
  239. public static final int ARRAY_BYTE_INDEX_SCALE = theUnsafe.arrayIndexScale(byte[].class);
  240. public static final int ARRAY_SHORT_INDEX_SCALE = theUnsafe.arrayIndexScale(short[].class);
  241. public static final int ARRAY_CHAR_INDEX_SCALE = theUnsafe.arrayIndexScale(char[].class);
  242. public static final int ARRAY_INT_INDEX_SCALE = theUnsafe.arrayIndexScale(int[].class);
  243. public static final int ARRAY_LONG_INDEX_SCALE = theUnsafe.arrayIndexScale(long[].class);
  244. public static final int ARRAY_FLOAT_INDEX_SCALE = theUnsafe.arrayIndexScale(float[].class);
  245. public static final int ARRAY_DOUBLE_INDEX_SCALE = theUnsafe.arrayIndexScale(double[].class);
  246. public static final int ARRAY_OBJECT_INDEX_SCALE = theUnsafe.arrayIndexScale(Object[].class);
  248. /**
  249.  *
  250.  *
  251.  *
  252.  *
  253.  */
  254. /**
  255.  * 返回通过putAddress()存储的本地指针的大小（以字节为单位），
  256.  * 这个值可能是4或8。
  257.  * 注意在其他基本类型的大小完全由它们的信息内存所决定的
  258.  */
  259. public native int addressSize();
  260. public static final int ADDRESS_SIZE = theUnsafe.addressSize();
  262. /**
  263.  * 本地内存页的大小
  264.  */
  265. public native int pageSize();
  272. // random trusted operations from JNI:
  273. /**
  274.  * 定义一个类，该类是完全可信的，不需要进行安全检查
  275.  */
  276. public native Class<?> defineClass(String name, byte[] b, int off, int len,
  277.                                    ClassLoader loader,
  278.                                    ProtectionDomain protectionDomain);
  280. /**
  281.  * 定义一个匿名类，该类不会被类加载器或系统字典所知道。
  282.  */
  283. public native Class<?> defineAnonymousClass(Class<?> hostClass, byte[] data, Object[] cpPatches);
  286. /**
  287.  * 实例化对象，但不需要经过任务构造器。
  288.  * 如果该类还没有被初始化，则初始化该类
  289.  */
  290. public native Object allocateInstance(Class<?> cls)
  291.     throws InstantiationException;
  293. // 与锁相关
  294. @Deprecated
  295. public native void monitorEnter(Object o);
  296. @Deprecated
  297. public native void monitorExit(Object o);
  298. @Deprecated
  299. public native boolean tryMonitorEnter(Object o);
  302. public native void throwException(Throwable ee);
  305. /**
  306.  * 「CAS」如果与期望值相等，则将对应属性更新为目标值
  307.  * @param o         目标对象
  308.  * @param offset    偏移量
  309.  * @param expected  期望值
  310.  * @param x         目标值
  311.  * @return
  312.  */
  313. public final native boolean compareAndSwapObject(Object o, long offset,
  314.                                                  Object expected,
  315.                                                  Object x);
  317. /**
  318.  * 「CAS」如果与期望值相等，则将对应属性更新为目标值
  319.  * @param o         目标对象
  320.  * @param offset    偏移量
  321.  * @param expected  期望值
  322.  * @param x          目标值
  323.  * @return
  324.  */
  325. public final native boolean compareAndSwapInt(Object o, long offset,
  326.                                               int expected,
  327.                                               int x);
  329. /**
  330.  * 「CAS」如果与期望值相等，则将对应属性更新为目标值
  331.  * @param o         目标对象
  332.  * @param offset    偏移量
  333.  * @param expected  期望值
  334.  * @param x          目标值
  335.  * @return
  336.  */
  337. public final native boolean compareAndSwapLong(Object o, long offset,
  338.                                                long expected,
  339.                                                long x);
  341. /**
  342.  * 使用「volatile load」语义从给定的Java变量中获取引用值
  343.  * 否则与getObject(Object, long)相同
  344.  */
  345. public native Object getObjectVolatile(Object o, long offset);
  346. /**
  347.  * 使用「volatile store」语义设置数据
  348.  * 否则与 putObject(Object, long, Object)相同
  349.  */
  350. public native void    putObjectVolatile(Object o, long offset, Object x);
  352. public native int     getIntVolatile(Object o, long offset);
  353. public native void    putIntVolatile(Object o, long offset, int x);
  355. public native boolean getBooleanVolatile(Object o, long offset);
  356. public native void    putBooleanVolatile(Object o, long offset, boolean x);
  358. public native byte    getByteVolatile(Object o, long offset);
  359. public native void    putByteVolatile(Object o, long offset, byte x);
  361. public native short   getShortVolatile(Object o, long offset);
  362. public native void    putShortVolatile(Object o, long offset, short x);
  364. public native char    getCharVolatile(Object o, long offset);
  365. public native void    putCharVolatile(Object o, long offset, char x);
  367. public native long    getLongVolatile(ObjectputOrderedObject
  368. o, long offset);
  369. public native void    putLongVolatile(Object o, long offset, long x);
  371. public native float   getFloatVolatile(Object o, long offset);putOrderedObject
  372. public native void    putFloatVolatile(Object o, long offset, float x);
  374. public native double  getDoubleVolatile(Object o, long offset);
  375. public native void    putDoubleVolatile(Object o, long offset, double x);
  377. /**
  378.  * 不保证存储值对其他线程立即可见，属于 putObjectVolatile(Object, long, Object) 版本。
  379.  * 在被volaile修饰的字段（或数组单元格，否则只能傅volatile访问）情况下才有用
  380.  */
  381. public native void    putOrderedObject(Object o, long offset, Object x);
  383. /** Ordered/Lazy version of {@link #putIntVolatile(Object, long, int)}  */
  384. public native void    putOrderedInt(Object o, long offset, int x);
  386. /** Ordered/Lazy version of {@link #putLongVolatile(Object, long, long)} */
  387. public native void    putOrderedLong(Object o, long offset, long x);
  389. /**
  390.  * 解除 对park上阻塞的 线程阻塞（Unblock the given thread blocked on park）
  391.  * 如果线程没有阻塞，则后续的调用也不阻塞。
  392.  * 注意: 这个操作「不安全」，仅仅是因为调用都必须以某种方式确保线程没有被销毁。
  393.  * 通常不需要特别的东西来确保这一点，但当通过「native」方法调用时，这几乎不是自动的。
  394.  */
  395. public native void unpark(Object thread);
  397. /**
  398.  * 阻塞当前线程，直到
  399.  * ① a balancing unpark occurs
  400.  * ② a balancing unpark has already occurred
  401.  * ③ 线程中断
  402.  * ④ isAbsolute=false&time>0，则时间单位为纳秒，经过time纳秒后返回。
  403.  * ⑤ isAbsolute=true&time>0，则时间单位为毫秒。经过time毫秒后返回。
  404.  * ⑥ 未知原因错误直接返回
  405.  * @param isAbsolute    是否为绝对时间
  406.  * @param time           等待时间值
  407.  */
  408. public native void park(boolean isAbsolute, long time);
  410. /**
  411.  * 获取分配给可用处理器的系统运行队列中在不同时间段的平均负载。
  412.  */
  413. public native int getLoadAverage(double[] loadavg, int nelems);
  419. // 非native的 CAS 实现
  421. /**
  422.  * 「CAS」原子地将给定值添加到给定对象o的偏移量offset处（字段或数组元素）
  423.  * @param o       目标对象
  424.  * @param offset  字段或元素偏移量
  425.  * @param delta   被加数
  426.  * @return         旧值
  427.  * @since 1.8
  428.  */
  429. public final int getAndAddInt(Object o, long offset, int delta) {
  430.     int v;
  431.     do {
  432.         // #1 获取旧值
  433.         v = getIntVolatile(o, offset);
  434.     // #2 通过「CAS」对于旧值是否可以更新，如果不可以，继续循环
  435.     } while (!compareAndSwapInt(o, offset, v, v + delta));
  436.     return v;
  437. }
  439. public final long getAndAddLong(Object o, long offset, long delta) {
  440.     long v;
  441.     do {
  442.         v = getLongVolatile(o, offset);
  443.     } while (!compareAndSwapLong(o, offset, v, v + delta));
  444.     return v;
  445. }
  447. public final int getAndSetInt(Object o, long offset, int newValue) {
  448.     int v;
  449.     do {
  450.         v = getIntVolatile(o, offset);
  451.     } while (!compareAndSwapInt(o, offset, v, newValue));
  452.     return v;
  453. }
  455. public final long getAndSetLong(Object o, long offset, long newValue) {
  456.     long v;
  457.     do {
  458.         v = getLongVolatile(o, offset);
  459.     } while (!compareAndSwapLong(o, offset, v, newValue));
  460.     return v;
  461. }
  463. public final Object getAndSetObject(Object o, long offset, Object newValue) {
  464.     Object v;
  465.     do {
  466.         v = getObjectVolatile(o, offset);
  467.     } while (!compareAndSwapObject(o, offset, v, newValue));
  468.     return v;
  469. }
  472. /**
  473.  * 「store」将处理器缓存的数据刷新到内存中。
  474.  * 「load」将内存存储的数据拷贝到处理器的缓存中。
  475.  * 「load_load_barriers」确保load1的数据装载先于load2及其后所有装载指令的操作。
  476.  * 「store_store_barriers」确保store1立刻刷新数据到内存（使其对其他处理器可见）的操作等于store2及其后所有存储指令的操作。
  477.  * 「load_store_barriers」确保load1的数据装载等于store2及其后所有的存储指令刷新数据到内存的操作。
  478.  * 「store_load_barriers」该屏障确保store1立刻刷新数据到内存的操作先于load2及其后所有装载指令的操作。
  479.  *                        它会使该屏障之前的所有内存访问指令（存储指令和访问指令）完成之后，才执行该屏障之后的内存访问指令。
  480.  *                        这一道内存屏障也称「全能屏障」
  481.  */
  482. // Ensures lack of reordering of loads before the fence with loads or stores after the fence.
  483. public native void loadFence();
  485. /**
  486.  * Ensures lack of reordering of stores before the fence
  487.  * with loads or stores after the fence.
  488.  * @since 1.8
  489.  */
  490. public native void storeFence();
  492. /**
  493.  * Ensures lack of reordering of loads or stores before the fence
  494.  * with loads or stores after the fence.
  495.  * @since 1.8
  496.  */
  497. public native void fullFence();
  499. /**
  500.  * Throws IllegalAccessError; for use by the VM.
  501.  * @since 1.8
  502.  */
  503. private static void throwIllegalAccessError() {
  504.    throw new IllegalAccessError();
  505. }
  507. /**
  508.  * 「big-endian」     本机字节顺序为「大端」，返回true
  509.  * 「little-endian」  本机字节顺序为「小端」，返回false
  510.  */
  511. public final boolean isBigEndian() { return BE; }
  513. /**
  514.  * @return Returns true if this platform is capable of performing
  515.  * accesses at addresses which are not aligned for the type of the
  516.  * primitive type being accessed, false ocompareAndSwapObject
  517.  therwise.
  518.  */
  520. public final boolean unalignedAccess() { return unalignedAccess; }
  522. // JVM interface methods
  523. private native boolean unalignedAccess0();
  524. private native boolean isBigEndian0();
  526. // BE is true iff the native endianness of this platform is big.
  527. private static final boolean BE = theUnsafe.isBigEndian0();
  529. // unalignedAccess is true iff this platform can perform unaligned accesses.
  530. private static final boolean unalignedAccess = theUnsafe.unalignedAccess0();

putOrderedObject

/**
 * 向目标对象x偏移量为offset处写入对象o的引用，
 * 内存立即可见（volatile 保证）
 */
public native void putObjectVolatile(Object o, long offset, Object x);

/**
 * 向目标对象o偏移量为offset处写入对象x的引用，
 * 有序、延迟可见，即不能保证其他线程立即看到，性能比putObjectVolatile要高
 * 这个方法能使用store-store屏障，性能损耗较小，而volatile使用store-load屏障，性能损耗高。
 */
public native void putOrderedObject(Object o, long offset, Object x);

首先将 volatile 变量转为普通变量提升性能，因为在 put 中需要读取到最新的数据，因此接下来调用 UNSAFE.getObjectVolatile 获取到最新的头结点，但是通过调用 UNSAFE.putOrderedObject 让变量写入主存的时间延迟到 put 方法的结尾，一来缩小临界区提升性能，而来也能保证其他线程读取到的是完整数据。

Unsafe 底层原理

JVM 源码位于 unsafe.cpp 上：

UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
  UnsafeWrapper("Unsafe_CompareAndSwapInt");
  oop p = JNIHandles::resolve(obj);
  jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
  return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
UNSAFE_END

从源码可见，它是通过 Atomic::cmpxchg 实现比较和替换操作。参数 x 是目标值，参数 e 是旧值，addr 为目标地址。
而更底层 Linux 操作系统实现如下：

inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint compare_value) {
  int mp = os::is_MP();
  __asm__ volatile (LOCK_IF_MP(%4) "cmpxchgl %1,(%3)"
                    : "=a" (exchange_value)
                    : "r" (exchange_value), "a" (compare_value), "r" (dest), "r" (mp)
                    : "cc", "memory");
  return exchange_value;
}

引用

  1. Java魔法类：Unsafe应用解析