JAVA Unsafe类详解
官方不建议使用Unsafe
使用Unsafe要注意以下几个问题：
1、Unsafe有可能在未来的Jdk版本移除或者不允许Java应用代码使用，这一点可能导致使用了Unsafe的应用无法运行在高版本的Jdk。
2、Unsafe的不少方法中必须提供原始地址(内存地址)和被替换对象的地址，偏移量要自己计算，一旦出现问题就是JVM崩溃级别的异常，会导致整个JVM实例崩溃，表现为应用程序直接crash掉。
3、Unsafe提供的直接内存访问的方法中使用的内存不受JVM管理(无法被GC)，需要手动管理，一旦出现疏忽很有可能成为内存泄漏的源头。
暂时总结出以上三点问题。Unsafe 在JUC (java.util.concurrent ) 包中大量使用 (主要是CAS)，在netty中方便使用直接内存，还有一些高并发的交易系统为了提高CAS的效率也有可能直接使用到Unsafe。总而言之，Unsafe类是一把双刃剑。
功能介绍
内存操作
这部分主要包含堆外内存的分配、拷贝、释放、给定地址值操作等方法。
//分配内存, 相当于C++的malloc函数
public native long allocateMemory(long bytes);
//扩充内存
public native long reallocateMemory(long address, long bytes);
//释放内存
public native void freeMemory(long address);
//在给定的内存块中设置值
public native void setMemory(Object o, long offset, long bytes, byte value);
//内存拷贝
public native void copyMemory(Object srcBase, long srcOffset, Object destBase, long destOffset, long bytes);
//获取给定地址值，忽略修饰限定符的访问限制。与此类似操作还有: getInt，getDouble，getLong，getChar等
public native Object getObject(Object o, long offset);
//为给定地址设置值，忽略修饰限定符的访问限制，与此类似操作还有: putInt,putDouble，putLong，putChar等
public native void putObject(Object o, long offset, Object x);
//获取给定地址的byte类型的值（当且仅当该内存地址为allocateMemory分配时，此方法结果为确定的）
public native byte getByte(long address);
//为给定地址设置byte类型的值（当且仅当该内存地址为allocateMemory分配时，此方法结果才是确定的）
public native void putByte(long address, byte x);
通常，我们在Java中创建的对象都处于堆内内存（heap）中，堆内内存是由JVM所管控的Java进程内存，并且它们遵循JVM的内存管理机制，JVM会采用垃圾回收机制统一管理堆内存。与之相对的是堆外内存，存在于JVM管控之外的内存区域，Java中对堆外内存的操作，依赖于Unsafe提供的操作堆外内存的native方法。
使用堆外内存的原因
- 对垃圾回收停顿的改善。由于堆外内存是直接受操作系统管理而不是JVM，所以当我们使用堆外内存时，即可保持较小的堆内内存规模。从而在GC时减少回收停顿对于应用的影响。
- 提升程序I/O操作的性能。通常在I/O通信过程中，会存在堆内内存到堆外内存的数据拷贝操作，对于需要频繁进行内存间数据拷贝且生命周期较短的暂存数据，都建议存储到堆外内存。
CAS相关
如下源代码释义所示，这部分主要为CAS相关操作的方法。
/**
* CAS
* @param o 包含要修改field的对象
* @param offset 对象中某field的偏移量
* @param expected 期望值
* @param update 更新值
* @return true | false
*/
public final native boolean compareAndSwapObject(Object o, long offset, Object expected, Object update);
public final native boolean compareAndSwapInt(Object o, long offset, int expected,int update);
public final native boolean compareAndSwapLong(Object o, long offset, long expected, long update);
什么是CAS? 即比较并替换，实现并发算法时常用到的一种技术。CAS操作包含三个操作数——内存位置、预期原值及新值。执行CAS操作的时候，将内存位置的值与预期原值比较，如果相匹配，那么处理器会自动将该位置值更新为新值，否则，处理器不做任何操作。我们都知道，CAS是一条CPU的原子指令（cmpxchg指令），不会造成所谓的数据不一致问题，Unsafe提供的CAS方法（如compareAndSwapXXX）底层实现即为CPU指令cmpxchg。
线程调度
这部分，包括线程挂起、恢复、锁机制等方法。
//取消阻塞线程
public native void unpark(Object thread);
//阻塞线程
public native void park(boolean isAbsolute, long time);
//获得对象锁（可重入锁）
@Deprecated
public native void monitorEnter(Object o);
//释放对象锁
@Deprecated
public native void monitorExit(Object o);
//尝试获取对象锁
@Deprecated
public native boolean tryMonitorEnter(Object o);
如上源码说明中，方法park、unpark即可实现线程的挂起与恢复，将一个线程进行挂起是通过park方法实现的，调用park方法后，线程将一直阻塞直到超时或者中断等条件出现；unpark可以终止一个挂起的线程，使其恢复正常。
典型应用
Java锁和同步器框架的核心类AbstractQueuedSynchronizer，就是通过调用LockSupport.park()和LockSupport.unpark()实现线程的阻塞和唤醒的，而LockSupport的park、unpark方法实际是调用Unsafe的park、unpark方式来实现。
Class相关
此部分主要提供Class和它的静态字段的操作相关方法，包含静态字段内存定位、定义类、定义匿名类、检验&确保初始化等。
//获取给定静态字段的内存地址偏移量，这个值对于给定的字段是唯一且固定不变的
public native long staticFieldOffset(Field f);
//获取一个静态类中给定字段的对象指针
public native Object staticFieldBase(Field f);
//判断是否需要初始化一个类，通常在获取一个类的静态属性的时候（因为一个类如果没初始化，它的静态属性也不会初始化）使用。 当且仅当ensureClassInitialized方法不生效时返回false。
public native boolean shouldBeInitialized(Class<?> c);
//检测给定的类是否已经初始化。通常在获取一个类的静态属性的时候（因为一个类如果没初始化，它的静态属性也不会初始化）使用。
public native void ensureClassInitialized(Class<?> c);
//定义一个类，此方法会跳过JVM的所有安全检查，默认情况下，ClassLoader（类加载器）和ProtectionDomain（保护域）实例来源于调用者
public native Class<?> defineClass(String name, byte[] b, int off, int len, ClassLoader loader, ProtectionDomain protectionDomain);
//定义一个匿名类
public native Class<?> defineAnonymousClass(Class<?> hostClass, byte[] data, Object[] cpPatches);
典型应用
从Java 8开始，JDK使用invokedynamic及VM Anonymous Class结合来实现Java语言层面上的Lambda表达式。
- invokedynamic： invokedynamic是Java 7为了实现在JVM上运行动态语言而引入的一条新的虚拟机指令，它可以实现在运行期动态解析出调用点限定符所引用的方法，然后再执行该方法，invokedynamic指令的分派逻辑是由用户设定的引导方法决定。
- VM Anonymous Class：可以看做是一种模板机制，针对于程序动态生成很多结构相同、仅若干常量不同的类时，可以先创建包含常量占位符的模板类，而后通过Unsafe.defineAnonymousClass方法定义具体类时填充模板的占位符生成具体的匿名类。生成的匿名类不显式挂在任何ClassLoader下面，只要当该类没有存在的实例对象、且没有强引用来引用该类的Class对象时，该类就会被GC回收。故而VM Anonymous Class相比于Java语言层面的匿名内部类无需通过ClassClassLoader进行类加载且更易回收。
在Lambda表达式实现中，通过invokedynamic指令调用引导方法生成调用点，在此过程中，会通过ASM动态生成字节码，而后利用Unsafe的defineAnonymousClass方法定义实现相应的函数式接口的匿名类，然后再实例化此匿名类，并返回与此匿名类中函数式方法的方法句柄关联的调用点；而后可以通过此调用点实现调用相应Lambda表达式定义逻辑的功能。
对象操作
此部分主要包含对象成员属性相关操作及非常规的对象实例化方式等相关方法。
//返回对象成员属性在内存地址相对于此对象的内存地址的偏移量
public native long objectFieldOffset(Field f);
//获得给定对象的指定地址偏移量的值，与此类似操作还有：getInt，getDouble，getLong，getChar等
public native Object getObject(Object o, long offset);
//给定对象的指定地址偏移量设值，与此类似操作还有：putInt，putDouble，putLong，putChar等
public native void putObject(Object o, long offset, Object x);
//从对象的指定偏移量处获取变量的引用，使用volatile的加载语义
public native Object getObjectVolatile(Object o, long offset);
//存储变量的引用到对象的指定的偏移量处，使用volatile的存储语义
public native void putObjectVolatile(Object o, long offset, Object x);
//有序、延迟版本的putObjectVolatile方法，不保证值的改变被其他线程立即看到。只有在field被volatile修饰符修饰时有效
public native void putOrderedObject(Object o, long offset, Object x);
//绕过构造方法、初始化代码来创建对象
public native Object allocateInstance(Class<?> cls) throws InstantiationException;
典型应用
- 常规对象实例化方式：我们通常所用到的创建对象的方式，从本质上来讲，都是通过new机制来实现对象的创建。但是，new机制有个特点就是当类只提供有参的构造函数且无显示声明无参构造函数时，则必须使用有参构造函数进行对象构造，而使用有参构造函数时，必须传递相应个数的参数才能完成对象实例化。
- 非常规的实例化方式：而Unsafe中提供allocateInstance方法，仅通过Class对象就可以创建此类的实例对象，而且不需要调用其构造函数、初始化代码、JVM安全检查等。它抑制修饰符检测，也就是即使构造器是private修饰的也能通过此方法实例化，只需提类对象即可创建相应的对象。由于这种特性，allocateInstance在java.lang.invoke、Objenesis（提供绕过类构造器的对象生成方式）、Gson（反序列化时用到）中都有相应的应用。
put/get
对象成员属性的内存偏移量获取，以及字段属性值的修改，在上面的例子中我们已经测试过了。除了前面的putInt、getInt方法外，Unsafe提供了全部8种基础数据类型以及Object的put和get方法，并且所有的put方法都可以越过访问权限，直接修改内存中的数据。阅读openJDK源码中的注释发现，基础数据类型和Object的读写稍有不同，基础数据类型是直接操作的属性值（value），而Object的操作则是基于引用值（reference value）。下面是Object的读写方法：
//在对象的指定偏移地址获取一个对象引用
public native Object getObject(Object o, long offset);
//在对象指定偏移地址写入一个对象引用
public native void putObject(Object o, long offset, Object x);
除了对象属性的普通读写外，Unsafe还提供了volatile读写和有序写入方法。volatile读写方法的覆盖范围与普通读写相同，包含了全部基础数据类型和Object类型，以int类型为例：
//在对象的指定偏移地址处读取一个int值，支持volatile load语义
public native int getIntVolatile(Object o, long offset);
//在对象指定偏移地址处写入一个int，支持volatile store语义
public native void putIntVolatile(Object o, long offset, int x);
相对于普通读写来说，volatile读写具有更高的成本，因为它需要保证可见性和有序性。在执行get操作时，会强制从主存中获取属性值，在使用put方法设置属性值时，会强制将值更新到主存中，从而保证这些变更对其他线程是可见的。
有序写入的方法有以下三个：
public native void putOrderedObject(Object o, long offset, Object x);
public native void putOrderedInt(Object o, long offset, int x);
public native void putOrderedLong(Object o, long offset, long x);
有序写入的成本相对volatile较低，因为它只保证写入时的有序性，而不保证可见性，也就是一个线程写入的值不能保证其他线程立即可见。为了解决这里的差异性，需要对内存屏障的知识点再进一步进行补充，首先需要了解两个指令的概念：
Load：将主内存中的数据拷贝到处理器的缓存中Store：将处理器缓存的数据刷新到主内存中
顺序写入与volatile写入的差别在于，在顺序写时加入的内存屏障类型为StoreStore类型，而在volatile写入时加入的内存屏障是StoreLoad类型
在有序写入方法中，使用的是StoreStore屏障，该屏障确保Store1立刻刷新数据到内存，这一操作先于Store2以及后续的存储指令操作。而在volatile写入中，使用的是StoreLoad屏障，该屏障确保Store1立刻刷新数据到内存，这一操作先于Load2及后续的装载指令，并且，StoreLoad屏障会使该屏障之前的所有内存访问指令，包括存储指令和访问指令全部完成之后，才执行该屏障之后的内存访问指令。
综上所述，在上面的三类写入方法中，在写入效率方面，按照put、putOrder、putVolatile的顺序效率逐渐降低，
allocateInstance
使用Unsafe的allocateInstance方法，允许我们使用非常规的方式进行对象的实例化，首先定义一个实体类，并且在构造函数中对其成员变量进行赋值操作：
@Data
public class A {
private int b;
public A(){
this.b =1;
}
}
分别基于构造函数、反射以及Unsafe方法的不同方式创建对象进行比较：
public void objTest() throws Exception{
A a1=new A();
System.out.println(a1.getB());
A a2 = A.class.newInstance();
System.out.println(a2.getB());
A a3= (A) unsafe.allocateInstance(A.class);
System.out.println(a3.getB());
}
打印结果分别为1、1、0，说明通过allocateInstance方法创建对象过程中，不会调用类的构造方法。使用这种方式创建对象时，只用到了Class对象，所以说如果想要跳过对象的初始化阶段或者跳过构造器的安全检查，就可以使用这种方法。在上面的例子中，如果将A类的构造函数改为private类型，将无法通过构造函数和反射创建对象，但allocateInstance方法仍然有效。
数组相关
这部分主要介绍与数据操作相关的arrayBaseOffset与arrayIndexScale这两个方法，两者配合起来使用，即可定位数组中每个元素在内存中的位置。
//返回数组中第一个元素的偏移地址
public native int arrayBaseOffset(Class<?> arrayClass);
//返回数组中一个元素占用对象头的大小
public native int arrayIndexScale(Class<?> arrayClass);
Demo:
public class ArrayTest {
public static void main(String[] args) throws IllegalAccessException, NoSuchFieldException {
Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafe.setAccessible(true);
Unsafe unsafe = (Unsafe)theUnsafe.get(null);
String[] array=new String[]{"str1str1str","str2","str3"};
int baseOffset = unsafe.arrayBaseOffset(String[].class);
System.out.println(baseOffset);
int scale = unsafe.arrayIndexScale(String[].class);
System.out.println(scale);
for (int i = 0; i < array.length; i++) {
int offset=baseOffset+scale*i;
System.out.println(offset+" : "+unsafe.getObject(array,offset));
}
}
}
Output:
16
4
16 : str1str1str
20 : str2
24 : str3
在String数组对象中，对象头包含3部分，mark word标记字占用8字节，klass point类型指针占用4字节，数组对象特有的数组长度部分占用4字节，总共占用了16字节。第一个String的引用类型相对于对象的首地址的偏移量是就16，之后每个元素在这个基础上加4，正好对应了我们上面代码中的寻址过程，之后再使用前面说过的getObject方法，通过数组对象可以获得对象在堆中的首地址，再配合对象中变量的偏移量，就能获得每一个变量的引用。
内存屏障
在Java 8中引入，用于定义内存屏障（也称内存栅栏，内存栅障，屏障指令等，是一类同步屏障指令，是CPU或编译器在对内存随机访问的操作中的一个同步点，使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作），避免代码重排序。
//内存屏障，禁止load操作重排序。屏障前的load操作不能被重排序到屏障后，屏障后的load操作不能被重排序到屏障前
public native void loadFence();
//内存屏障，禁止store操作重排序。屏障前的store操作不能被重排序到屏障后，屏障后的store操作不能被重排序到屏障前
public native void storeFence();
//内存屏障，禁止load、store操作重排序
public native void fullFence();
Demo:
@Slf4j
public class BarrierTest {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
@Getter
class ChangeThread implements Runnable {
/** volatile **/
boolean flag = false;
@Override
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info("subThread change flag to:" + flag);
flag = true;
}
}
ChangeThread changeThread = new ChangeThread();
new Thread(changeThread).start();
Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafe.setAccessible(true);
Unsafe unsafe = (Unsafe)theUnsafe.get(null);
log.info("main thread begin");
while (true) {
boolean flag = changeThread.isFlag();
unsafe.loadFence(); // 加入读内存屏障
if (flag) {
log.info("detected flag changed");
break;
}
}
log.info("main thread end");
}
}
Output:
23:59:01.616 [main] INFO com.qhong.disruptor.unsafe.BarrierTest - main thread begin
23:59:04.615 [Thread-0] INFO com.qhong.disruptor.unsafe.BarrierTest - subThread change flag to:false
23:59:04.615 [main] INFO com.qhong.disruptor.unsafe.BarrierTest - detected flag changed
23:59:04.615 [main] INFO com.qhong.disruptor.unsafe.BarrierTest - main thread end
而如果删掉上面代码中的loadFence方法，那么主线程将无法感知到flag发生的变化，会一直在while中循环。
java内存模型（JMM）中，运行中的线程不是直接读取主内存中的变量的，只能操作自己工作内存中的变量，然后同步到主内存中，并且线程的工作内存是不能共享的。上面demo就是子线程借助于主内存，将修改后的结果同步给了主线程，进而修改主线程中的工作空间，跳出循环。
系统相关
这部分包含两个获取系统相关信息的方法。
//返回系统指针的大小。返回值为4（32位系统）或 8（64位系统）。
public native int addressSize();
//内存页的大小，此值为2的幂次方。
public native int pageSize();
Unsafe Code
//下面是sun.misc.Unsafe.java类源码
package sun.misc;
import java.lang.reflect.Field;
/***
* This class should provide access to low-level operations and its
* use should be limited to trusted code. Fields can be accessed using
* memory addresses, with undefined behaviour occurring if invalid memory
* addresses are given.
* 这个类提供了一个更底层的操作并且应该在受信任的代码中使用。可以通过内存地址
* 存取fields,如果给出的内存地址是无效的那么会有一个不确定的运行表现。
*
* @author Tom Tromey ([email protected])
* @author Andrew John Hughes ([email protected])
*/
public class Unsafe
{
// Singleton class.
private static Unsafe unsafe = new Unsafe();
/***
* Private default constructor to prevent creation of an arbitrary
* number of instances.
* 使用私有默认构造器防止创建多个实例
*/
private Unsafe()
{
}
/***
* Retrieve the singleton instance of <code>Unsafe</code>. The calling
* method should guard this instance from untrusted code, as it provides
* access to low-level operations such as direct memory access.
* 获取<code>Unsafe</code>的单例,这个方法调用应该防止在不可信的代码中实例，
* 因为unsafe类提供了一个低级别的操作，例如直接内存存取。
*
* @throws SecurityException if a security manager exists and prevents
* access to the system properties.
* 如果安全管理器不存在或者禁止访问系统属性
*/
public static Unsafe getUnsafe()
{
SecurityManager sm = System.getSecurityManager();
if (sm != null)
sm.checkPropertiesAccess();
return unsafe;
}
/***
* Returns the memory address offset of the given static field.
* The offset is merely used as a means to access a particular field
* in the other methods of this class. The value is unique to the given
* field and the same value should be returned on each subsequent call.
* 返回指定静态field的内存地址偏移量,在这个类的其他方法中这个值只是被用作一个访问
* 特定field的一个方式。这个值对于 给定的field是唯一的，并且后续对该方法的调用都应该
* 返回相同的值。
*
* @param field the field whose offset should be returned.
* 需要返回偏移量的field
* @return the offset of the given field.
* 指定field的偏移量
*/
public native long objectFieldOffset(Field field);
/***
* Compares the value of the integer field at the specified offset
* in the supplied object with the given expected value, and updates
* it if they match. The operation of this method should be atomic,
* thus providing an uninterruptible way of updating an integer field.
* 在obj的offset位置比较integer field和期望的值，如果相同则更新。这个方法
* 的操作应该是原子的，因此提供了一种不可中断的方式更新integer field。
*
* @param obj the object containing the field to modify.
* 包含要修改field的对象
* @param offset the offset of the integer field within <code>obj</code>.
* <code>obj</code>中整型field的偏移量
* @param expect the expected value of the field.
* 希望field中存在的值
* @param update the new value of the field if it equals <code>expect</code>.
* 如果期望值expect与field的当前值相同，设置filed的值为这个新值
* @return true if the field was changed.
* 如果field的值被更改
*/
public native boolean compareAndSwapInt(Object obj, long offset,
int expect, int update);
/***
* Compares the value of the long field at the specified offset
* in the supplied object with the given expected value, and updates
* it if they match. The operation of this method should be atomic,
* thus providing an uninterruptible way of updating a long field.
* 在obj的offset位置比较long field和期望的值，如果相同则更新。这个方法
* 的操作应该是原子的，因此提供了一种不可中断的方式更新long field。
*
* @param obj the object containing the field to modify.
* 包含要修改field的对象
* @param offset the offset of the long field within <code>obj</code>.
* <code>obj</code>中long型field的偏移量
* @param expect the expected value of the field.
* 希望field中存在的值
* @param update the new value of the field if it equals <code>expect</code>.
* 如果期望值expect与field的当前值相同，设置filed的值为这个新值
* @return true if the field was changed.
* 如果field的值被更改
*/
public native boolean compareAndSwapLong(Object obj, long offset,
long expect, long update);
/***
* Compares the value of the object field at the specified offset
* in the supplied object with the given expected value, and updates
* it if they match. The operation of this method should be atomic,
* thus providing an uninterruptible way of updating an object field.
* 在obj的offset位置比较object field和期望的值，如果相同则更新。这个方法
* 的操作应该是原子的，因此提供了一种不可中断的方式更新object field。
*
* @param obj the object containing the field to modify.
* 包含要修改field的对象
* @param offset the offset of the object field within <code>obj</code>.
* <code>obj</code>中object型field的偏移量
* @param expect the expected value of the field.
* 希望field中存在的值
* @param update the new value of the field if it equals <code>expect</code>.
* 如果期望值expect与field的当前值相同，设置filed的值为这个新值
* @return true if the field was changed.
* 如果field的值被更改
*/
public native boolean compareAndSwapObject(Object obj, long offset,
Object expect, Object update);
/***
* Sets the value of the integer field at the specified offset in the
* supplied object to the given value. This is an ordered or lazy
* version of <code>putIntVolatile(Object,long,int)</code>, which
* doesn't guarantee the immediate visibility of the change to other
* threads. It is only really useful where the integer field is
* <code>volatile</code>, and is thus expected to change unexpectedly.
* 设置obj对象中offset偏移地址对应的整型field的值为指定值。这是一个有序或者
* 有延迟的<code>putIntVolatile</cdoe>方法，并且不保证值的改变被其他线程立
* 即看到。只有在field被<code>volatile</code>修饰并且期望被意外修改的时候
* 使用才有用。
*
* @param obj the object containing the field to modify.
* 包含需要修改field的对象
* @param offset the offset of the integer field within <code>obj</code>.
* <code>obj</code>中整型field的偏移量
* @param value the new value of the field.
* field将被设置的新值
* @see #putIntVolatile(Object,long,int)
*/
public native void putOrderedInt(Object obj, long offset, int value);
/***
* Sets the value of the long field at the specified offset in the
* supplied object to the given value. This is an ordered or lazy
* version of <code>putLongVolatile(Object,long,long)</code>, which
* doesn't guarantee the immediate visibility of the change to other
* threads. It is only really useful where the long field is
* <code>volatile</code>, and is thus expected to change unexpectedly.
* 设置obj对象中offset偏移地址对应的long型field的值为指定值。这是一个有序或者
* 有延迟的<code>putLongVolatile</cdoe>方法，并且不保证值的改变被其他线程立
* 即看到。只有在field被<code>volatile</code>修饰并且期望被意外修改的时候
* 使用才有用。
*
* @param obj the object containing the field to modify.
* 包含需要修改field的对象
* @param offset the offset of the long field within <code>obj</code>.
* <code>obj</code>中long型field的偏移量
* @param value the new value of the field.
* field将被设置的新值
* @see #putLongVolatile(Object,long,long)
*/
public native void putOrderedLong(Object obj, long offset, long value);
/***
* Sets the value of the object field at the specified offset in the
* supplied object to the given value. This is an ordered or lazy
* version of <code>putObjectVolatile(Object,long,Object)</code>, which
* doesn't guarantee the immediate visibility of the change to other
* threads. It is only really useful where the object field is
* <code>volatile</code>, and is thus expected to change unexpectedly.
* 设置obj对象中offset偏移地址对应的object型field的值为指定值。这是一个有序或者
* 有延迟的<code>putObjectVolatile</cdoe>方法，并且不保证值的改变被其他线程立
* 即看到。只有在field被<code>volatile</code>修饰并且期望被意外修改的时候
* 使用才有用。
*
* @param obj the object containing the field to modify.
* 包含需要修改field的对象
* @param offset the offset of the object field within <code>obj</code>.
* <code>obj</code>中long型field的偏移量
* @param value the new value of the field.
* field将被设置的新值
*/
public native void putOrderedObject(Object obj, long offset, Object value);
/***
* Sets the value of the integer field at the specified offset in the
* supplied object to the given value, with volatile store semantics.
* 设置obj对象中offset偏移地址对应的整型field的值为指定值。支持volatile store语义
*
* @param obj the object containing the field to modify.
* 包含需要修改field的对象
* @param offset the offset of the integer field within <code>obj</code>.
* <code>obj</code>中整型field的偏移量
* @param value the new value of the field.
* field将被设置的新值
*/
public native void putIntVolatile(Object obj, long offset, int value);
/***
* Retrieves the value of the integer field at the specified offset in the
* supplied object with volatile load semantics.
* 获取obj对象中offset偏移地址对应的整型field的值,支持volatile load语义。
*
* @param obj the object containing the field to read.
* 包含需要去读取的field的对象
* @param offset the offset of the integer field within <code>obj</code>.
* <code>obj</code>中整型field的偏移量
*/
public native int getIntVolatile(Object obj, long offset);
/***
* Sets the value of the long field at the specified offset in the
* supplied object to the given value, with volatile store semantics.
* 设置obj对象中offset偏移地址对应的long型field的值为指定值。支持volatile store语义
*
* @param obj the object containing the field to modify.
* 包含需要修改field的对象
* @param offset the offset of the long field within <code>obj</code>.
* <code>obj</code>中long型field的偏移量
* @param value the new value of the field.
* field将被设置的新值
* @see #putLong(Object,long,long)
*/
public native void putLongVolatile(Object obj, long offset, long value);
/***
* Sets the value of the long field at the specified offset in the
* supplied object to the given value.
* 设置obj对象中offset偏移地址对应的long型field的值为指定值。
*
* @param obj the object containing the field to modify.
* 包含需要修改field的对象
* @param offset the offset of the long field within <code>obj</code>.
* <code>obj</code>中long型field的偏移量
* @param value the new value of the field.
* field将被设置的新值
* @see #putLongVolatile(Object,long,long)
*/
public native void putLong(Object obj, long offset, long value);
/***
* Retrieves the value of the long field at the specified offset in the
* supplied object with volatile load semantics.
* 获取obj对象中offset偏移地址对应的long型field的值,支持volatile load语义。
*
* @param obj the object containing the field to read.
* 包含需要去读取的field的对象
* @param offset the offset of the long field within <code>obj</code>.
* <code>obj</code>中long型field的偏移量
* @see #getLong(Object,long)
*/
public native long getLongVolatile(Object obj, long offset);
/***
* Retrieves the value of the long field at the specified offset in the
* supplied object.
* 获取obj对象中offset偏移地址对应的long型field的值
*
* @param obj the object containing the field to read.
* 包含需要去读取的field的对象
* @param offset the offset of the long field within <code>obj</code>.
* <code>obj</code>中long型field的偏移量
* @see #getLongVolatile(Object,long)
*/
public native long getLong(Object obj, long offset);
/***
* Sets the value of the object field at the specified offset in the
* supplied object to the given value, with volatile store semantics.
* 设置obj对象中offset偏移地址对应的object型field的值为指定值。支持volatile store语义
*
* @param obj the object containing the field to modify.
* 包含需要修改field的对象
* @param offset the offset of the object field within <code>obj</code>.
* <code>obj</code>中object型field的偏移量
* @param value the new value of the field.
* field将被设置的新值
* @see #putObject(Object,long,Object)
*/
public native void putObjectVolatile(Object obj, long offset, Object value);
/***
* Sets the value of the object field at the specified offset in the
* supplied object to the given value.
* 设置obj对象中offset偏移地址对应的object型field的值为指定值。
*
* @param obj the object containing the field to modify.
* 包含需要修改field的对象
* @param offset the offset of the object field within <code>obj</code>.
* <code>obj</code>中object型field的偏移量
* @param value the new value of the field.
* field将被设置的新值
* @see #putObjectVolatile(Object,long,Object)
*/
public native void putObject(Object obj, long offset, Object value);
/***
* Retrieves the value of the object field at the specified offset in the
* supplied object with volatile load semantics.
* 获取obj对象中offset偏移地址对应的object型field的值,支持volatile load语义。
*
* @param obj the object containing the field to read.
* 包含需要去读取的field的对象
* @param offset the offset of the object field within <code>obj</code>.
* <code>obj</code>中object型field的偏移量
*/
public native Object getObjectVolatile(Object obj, long offset);
/***
* Returns the offset of the first element for a given array class.
* To access elements of the array class, this value may be used along with
* with that returned by
* <a href="#arrayIndexScale"><code>arrayIndexScale</code></a>,
* if non-zero.
* 获取给定数组中第一个元素的偏移地址。
* 为了存取数组中的元素，这个偏移地址与<a href="#arrayIndexScale"><code>arrayIndexScale
* </code></a>方法的非0返回值一起被使用。
* @param arrayClass the class for which the first element's address should
* be obtained.
* 第一个元素地址被获取的class
* @return the offset of the first element of the array class.
* 数组第一个元素 的偏移地址
* @see arrayIndexScale(Class)
*/
public native int arrayBaseOffset(Class arrayClass);
/***
* Returns the scale factor used for addressing elements of the supplied
* array class. Where a suitable scale factor can not be returned (e.g.
* for primitive types), zero should be returned. The returned value
* can be used with
* <a href="#arrayBaseOffset"><code>arrayBaseOffset</code></a>
* to access elements of the class.
* 获取用户给定数组寻址的换算因子.一个合适的换算因子不能返回的时候(例如：基本类型),
* 返回0.这个返回值能够与<a href="#arrayBaseOffset"><code>arrayBaseOffset</code>
* </a>一起使用去存取这个数组class中的元素
*
* @param arrayClass the class whose scale factor should be returned.
* @return the scale factor, or zero if not supported for this array class.
*/
public native int arrayIndexScale(Class arrayClass);
/***
* Releases the block on a thread created by
* <a href="#park"><code>park</code></a>. This method can also be used
* to terminate a blockage caused by a prior call to <code>park</code>.
* This operation is unsafe, as the thread must be guaranteed to be
* live. This is true of Java, but not native code.
* 释放被<a href="#park"><code>park</code></a>创建的在一个线程上的阻塞.这个
* 方法也可以被使用来终止一个先前调用<code>park</code>导致的阻塞.
* 这个操作操作时不安全的,因此线程必须保证是活的.这是java代码不是native代码。
* @param thread the thread to unblock.
* 要解除阻塞的线程
*/
public native void unpark(Thread thread);
/***
* Blocks the thread until a matching
* <a href="#unpark"><code>unpark</code></a> occurs, the thread is
* interrupted or the optional timeout expires. If an <code>unpark</code>
* call has already occurred, this also counts. A timeout value of zero
* is defined as no timeout. When <code>isAbsolute</code> is
* <code>true</code>, the timeout is in milliseconds relative to the
* epoch. Otherwise, the value is the number of nanoseconds which must
* occur before timeout. This call may also return spuriously (i.e.
* for no apparent reason).
* 阻塞一个线程直到<a href="#unpark"><code>unpark</code></a>出现、线程
* 被中断或者timeout时间到期。如果一个<code>unpark</code>调用已经出现了，
* 这里只计数。timeout为0表示永不过期.当<code>isAbsolute</code>为true时，
* timeout是相对于新纪元之后的毫秒。否则这个值就是超时前的纳秒数。这个方法执行时
* 也可能不合理地返回(没有具体原因)
*
* @param isAbsolute true if the timeout is specified in milliseconds from
* the epoch.
* 如果为true timeout的值是一个相对于新纪元之后的毫秒数
* @param time either the number of nanoseconds to wait, or a time in
* milliseconds from the epoch to wait for.
* 可以是一个要等待的纳秒数，或者是一个相对于新纪元之后的毫秒数直到
* 到达这个时间点
*/
public native void park(boolean isAbsolute, long time);
}