参考：《Java魔法类：Unsafe应用解析》

1 引子

Java中没有指针，不能直接对内存地址的变量进行控制，但Java提供了一个特殊的类Unsafe工具类来间接实现。Unsafe主要提供一些用于执行低级别、不安全操作的方法，如直接访问系统内存资源、自主管理内存资源等，这些方法在提升Java运行效率、增强Java语言底层资源操作能力方面起到了很大的作用 。正如其名字unsafe，直接去使用这个工具类是不安全的，它能直接在硬件层（内存上）修改访问变量，而无视各种访问修饰符的限制。它几乎所有的公共方法API都是本地方法，这些方法是使用C/C++方法实现的，它越过了虚拟机层面，直接在操作系统本地执行。因为这是一个底层类，如果在不了解其内部原理、未掌握其使用技巧的情况下，我们直接使用Unsafe类可能会造成一些意想不到或未知的错误，所以它被限制开发者直接使用，只能由JDK类库的维护者使用。如果您喜欢阅读JDK的源码，那么你会发现在各种并发工具类的内部常常见到这个类的踪影，它们经常通过这个类的一些方法根据相应内存地址在内存上直接CAS修改访问共享变量的值。

Unsafe类在Oracle的官方JDK中没有提供源码，我们只能通过IDEA的反编译工具看到反编译后的源代码，因此我们看不到方法注释。而只OpenJDK中带有所有JDK的源代码，这里使用OpenJDK作参考讲解材料。以下是OpenJDK中Unsafe的类注释

A collection of methods for performing low-level, unsafe operations. Although the class and all methods are public, use of this class is limited because only trusted code can obtain instances of it.

直译过来大致意思是：此类拥有一组用于执行低级，不安全操作的方法。 尽管此类和所有方法都是公共的，但是由于只有可信代码才能获取该类的实例，因此此类的使用受到限制。

可以看出构造方法被私有化，只能通过静态方法getUnsafe（）才能获取此Unsafe单例对象，而此静态方法的使用也是受到限制的，只能由JDK中的其它类来调用，普通开发者使用此方法将抛出异常。

  1.     private Unsafe() {}
  3.     private static final Unsafe theUnsafe = new Unsafe();
  5.     @CallerSensitive
  6.     public static Unsafe getUnsafe() {
  7.         Class<?> caller = Reflection.getCallerClass(); //调用者Class对象
  8.         if (!VM.isSystemDomainLoader(caller.getClassLoader())) //判断调用者的类加载器是否为系统类加载器
  9.             //不是JAVA_HOME/jre/lib目录下jar包中的类来调用此方法getUnsafe（）就会抛出异常
  10.             throw new SecurityException("Unsafe");
  11.         return theUnsafe;
  12.     }

Java Unsafe类详解 - 图1

此方法getUnsafe()上的注释也说：

为调用提供执行不安全操作的能力。返回的Unsafe对象应由调用方小心保护，因为它可用于在任意内存地址处读取和写入数据。 绝不能将其传递给不受信任的代码。此类中的大多数方法都是非常底层的，并且对应于少量的硬件指令（在典型的机器上）。 应鼓励编译器相应地优化这些方法，而不是使用Unsafe类来控制。

  1. getUnsafe()要求JDK类库自身调用，当然将开发者可以将自己定义的类放在JDK系统类库中，但这种方式明显是不安全、不方便的，其可行性太低。倘若开发者的确需要使用Unsafe类，我们可以使用反射的方式获取Unsafe实例。
  1.     private static Unsafe getUnsafeByReflect() {
  2.         try {
  3.             Field f = Unsafe.class.getDeclaredField("theUnsafe");
  4.             f.setAccessible(true);
  5.             return (Unsafe) f.get(null);
  6.         } catch (Exception e) {
  7.             throw new Error(e);
  8.         }
  9.     }

使用反射方式，在开发者的classpath中获取到Unsafe实例

  1. package com.aaxis;
  3. import java.lang.reflect.Field;
  5. import sun.misc.Unsafe;
  7. public class Student {
  8.     private int stuId;
  9.     private String name;
  10.     private int age;
  11.     private static final long STUID_OFFSET;
  12.     private static final Unsafe UNSAFE = getUnsafeByReflect();
  13.     static {
  14.         try {
  15.             STUID_OFFSET = UNSAFE.objectFieldOffset(Student.class.getDeclaredField("stuId"));
  16.         } catch (NoSuchFieldException | SecurityException e) {
  17.             throw new Error(e);
  18.         }
  20.     }
  21.     private static Unsafe getUnsafeByReflect() {
  22.         try {
  23.             Field f = Unsafe.class.getDeclaredField("theUnsafe");
  24.             f.setAccessible(true);
  25.             return (Unsafe) f.get(null);
  26.         } catch (Exception e) {
  27.             throw new Error(e);
  28.         }
  29.     }
  31.     public static void unsafedPrintStuId() {
  32.         Student student = new Student(34124, "小黄");
  33.         int stuId = UNSAFE.getInt(student, STUID_OFFSET);
  35.         System.out.println(student.getName() + "学号：" + stuId);
  36.     }
  37.     public static void main(String[] args) {
  38.         unsafedPrintStuId();
  39.     }
  40.      //.....
  42. }

Unsafe类的主要功能如图：

Java Unsafe类详解 - 图2

2 Java对象相关操作

注意：因为反射中使用Field描述实例变量和静态变量，现在将实例变量和静态变量统称为字段。

获取字段相对偏移量

  1. /**
  2.  *  根据反射的字段f,获取相应实例变量的偏移量
  3.  *  此偏移量是实例变量的起始地址与对象的起始地址之差，对于一确定的java类，某字段与对象之间的起始地址之差是常数，
  4.  *  静态变量的偏移量与此类似
  5.  */
  6. public native long staticFieldOffset(Field f);
  7. //根据反射的字段f,获取相应静态变量的偏移量（静态变量的起始地址与相应静态区Klass对象起始地址之差）
  8. public native long objectFieldOffset(Field f);

这里提到了字段的偏移量，这与Java对象的内存布局有密切关系。Java对象由对象头和实际数据两部分组成。

下图中MarkWord包含对象的hashCode、锁信息、垃圾回收的分代信息等，占32/64位；Class Metadata Pointer表示一个此对象数据类型的Class对象（虚拟机中的Klass对象）的指针，占32/64位；ArrayLength是数组对象特有的内容，表示数组的长度，占32位。数组对象的实际数据是各个元素的值或引用，普通对象的实际数据是各实例字段的值或引用。另外为了快速内存分配、快速内存寻址、提高性能，Java语言规范要求Java对象要做内存对齐处理，每个对象占用的内存字节数必须是8的倍数，若不是则要填零补足对齐。

从下图可以看出，字段与对象头之间的偏移量是固定的，只要知道字段的相对偏移量和对象起始地址，我们就能获取此字段的绝对内存地址（fieldAddress=objAddress+fieldOffset），根据此绝对内存地址，我们就能忽略访问修饰符的限制而可直接读取/修改此字段的值或引用。

数组对象的元素内存定址，相对对于普通对象的字段定址有些不一样，它要先计算出对象头的长度，作为基础偏移量；由于数组元素的数据类型是相同的，每个元素的值或引用所占内存空间是相同的，因此将元素值或引用或占内存作为每两相邻元素的相对偏移量。根据对象起始位置、基础偏移量、相邻元素相对偏移量及数组下标，就可以获取到某个元素值或引用的绝对内存地址(itemAddress=arrayAddress+baseOffset+index*indexOffset),进而通过绝对内存地址读取或修改此元素的值或引用。

Java Unsafe类详解 - 图3

根据字段偏移量设置/获取字段值

  1.     //根据反射的字段f,获取相应的静态变量的值
  2.     public native Object staticFieldBase(Field f);
  4.     /**
  5.      *参数o是字段所属的对象，offset表示相对偏移量，参数x是此字段要设置的新值
  6.      */
  8.     /*字段是引用数据类型*/
  9.     public native Object getObject(Object o, long offset);//获取字段值
  10.     public native void putObject(Object o, long offset, Object x);//设置字段值
  12.     /*字段为基本数据类型*/
  13.     public native void putInt(Object o, long offset, int x);
  14.     public native int getInt(Object o, long offset);
  15.     public native boolean getBoolean(Object o, long offset);
  16.     public native void    putBoolean(Object o, long offset, boolean x);
  17.     public native byte    getByte(Object o, long offset);
  18.     public native void    putByte(Object o, long offset, byte x);
  19.     public native short   getShort(Object o, long offset);
  20.     public native void    putShort(Object o, long offset, short x);
  21.     public native char    getChar(Object o, long offset);
  22.     public native void    putChar(Object o, long offset, char x);
  23.     public native long    getLong(Object o, long offset);
  24.     public native void    putLong(Object o, long offset, long x);
  25.     public native float   getFloat(Object o, long offset);
  26.     public native void    putFloat(Object o, long offset, float x);
  27.     public native double  getDouble(Object o, long offset);
  28.     public native void    putDouble(Object o, long offset, double x);

使用示例：

我将一个自定义的普通（编译后的）Java类放在JDK类库的charset.jar包中，这个Student类使用了Unsafe类。

Java Unsafe类详解 - 图4

Student.class的部分反编译源码

Java Unsafe类详解 - 图5Student部分代码

测试Unsafe能否忽略访问限制，读取私有变量

  1. package other;
  3. import sun.awt.Student;
  5. public class UnsafeTest {
  6.     public static void main(String[] args) {
  7.         Student.unsafedPrintStuId();
  8.     }
  9. }

控制台输出结果正确

Java Unsafe类详解 - 图6

volatile版本根据字段偏移量设置/获取字段值(加上volatile语义)

保证对其他线程的可见性（只有字段被volatile修饰时有效）

  1.     //volatile形式地获取字段值，即使在多线条件下，从主内存中获取值，使当前线程的工作内存的缓存值失效
  2.     public native Object getObjectVolatile(Object o, long offset);
  3.     //volatile形式地设置字段值，即使在多线条件下，设置的值将只保存到主内存中，不加载到线程本地缓存，保证可见性
  4.     public native void    putObjectVolatile(Object o, long offset, Object x);
  5.     public native int     getIntVolatile(Object o, long offset);
  6.     public native void    putIntVolatile(Object o, long offset, int x);
  7.     public native boolean getBooleanVolatile(Object o, long offset);
  8.     public native void    putBooleanVolatile(Object o, long offset, boolean x);
  9.     public native byte    getByteVolatile(Object o, long offset);
  10.     public native void    putByteVolatile(Object o, long offset, byte x);
  11.     public native short   getShortVolatile(Object o, long offset);
  12.     public native void    putShortVolatile(Object o, long offset, short x);
  13.     public native char    getCharVolatile(Object o, long offset);
  14.     public native void    putCharVolatile(Object o, long offset, char x);
  15.     public native long    getLongVolatile(Object o, long offset);
  16.     public native void    putLongVolatile(Object o, long offset, long x);
  17.     public native float   getFloatVolatile(Object o, long offset);
  18.     public native void    putFloatVolatile(Object o, long offset, float x);
  19.     public native double  getDoubleVolatile(Object o, long offset);
  20.     public native void    putDoubleVolatile(Object o, long offset, double x);

有序延迟化地设置字段值

  1. 有序延迟化设值，对其他线程不保证可见性
  1.     //有序延迟化地设置字段值，
  2.     public native void    putOrderedObject(Object o, long offset, Object x);
  3.     /** Ordered/Lazy version of {@link #putIntVolatile(Object, long, int)}  */
  4.     public native void    putOrderedInt(Object o, long offset, int x);
  5.     /** Ordered/Lazy version of {@link #putLongVolatile(Object, long, long)} */
  6.     public native void    putOrderedLong(Object o, long offset, long x);

数组相关的偏移量

  1.     //第一个元素与数组对象两者间起始地址之差(首元素与对象头的相对偏移量）
  2.     public native int arrayBaseOffset(Class<?> arrayClass);
  4.     //相邻元素间相对偏移量的位移表示(返回值的二进制形式的有效位数是x，那么相邻元素的偏移量就是2的x次方)
  5.     public native int arrayIndexScale(Class<?> arrayClass);

使用示例：

java.util.concurrent.atomic.AtomicIntegerArray包下的AtomicIntegerArray结合以上两个方法，进行数组元素地址定位。

  1. class AtomicIntegerArray implements java.io.Serializable {
  2.     private static final long serialVersionUID = 2862133569453604235L;
  4.     private static final Unsafe unsafe = Unsafe.getUnsafe();
  5.     private static final int   base   = unsafe.arrayBaseOffset(int[].class);
  6.     private static final int   shift;
  7.     private final        int[] array;
  8.     static {
  9.         int scale = unsafe.arrayIndexScale(int[].class);
  10.         if ((scale & (scale - 1)) != 0)
  11.             throw new Error("data type scale not a power of two");
  12.         shift = 31 - Integer.numberOfLeadingZeros(scale);
  13.     }
  14.     private long checkedByteOffset(int i) {
  15.         if (i < 0 || i >= array.length)
  16.             throw new IndexOutOfBoundsException("index " + i);
  18.         return byteOffset(i);
  19.     }
  20.     private static long byteOffset(int i) {
  21.         return ((long) i << shift) + base;
  22.     }
  23.     public final void set(int i, int newValue) {
  24.         unsafe.putIntVolatile(array, checkedByteOffset(i), newValue);
  25.     }
  26. }

3 Class相关操作

创建Java类

  1.     /**
  2.      * 让虚拟机知道我们定义一个类，但不进行安全检查。 
  3.      * 默认情况下，类加载器和保护域来自调用者的类。
  4.      */
  5.     public native Class<?> defineClass(String name, byte[] b, int off, int len,
  6.                                        ClassLoader loader,
  7.                                        ProtectionDomain protectionDomain);
  9.     /*
  10.     * 在类加载器和系统字典（system dictionary)不知道的情况下根据字节码数据定义一个匿名的Class对象，相当于创建了一个Java类
  11.      * @params hostClass context for linkage, access control, protection domain, and class loader
  12.      * @params data     字节码文件对应的字节数组
  13.      * @params cpPatches where non-null entries exist, they replace corresponding CP entries in data
  14.      */
  15.     public native Class<?> defineAnonymousClass(Class<?> hostClass, byte[] data, Object[] cpPatches);

Java类初始化

shouldBeInitialized（Class）方法检测Class对应的Java类是否被初始化
ensureClassInitialized（Class)方法强制Java类初始化，若没初始化则进行初始化。
这两个方法常与staticFieldBase(Field)一起使用，因为如果Java类没有被初始化，静态变量便没有初始化，就不能直接获取静态变量的引用。

  1.   /**
  2.      * Detect if the given class may need to be initialized. This is often
  3.      * needed in conjunction with obtaining the static field base of a
  4.      * class.
  5.      * @return false only if a call to {@code ensureClassInitialized} would have no effect
  6.      */
  7.     public native boolean shouldBeInitialized(Class<?> c);
  9.     /**
  10.      * Ensure the given class has been initialized. This is often
  11.      * needed in conjunction with obtaining the static field base of a
  12.      * class.
  13.      */
  14.     public native void ensureClassInitialized(Class<?> c);

使用示例：

java.lang.invoke.DirectMethodHandle中的checkInitialized(MemberName)方法调用了以上两个与类初始化相关的方法

Java Unsafe类详解 - 图7

根据Class创建对象

仅通过Class对象就可以创建此类的实例对象，而且不需要调用其构造函数、初始化代码、JVM安全检查，等,。它抑制修饰符检测，也就是即使构造器是private修饰的也能通过此方法实例化，只需提类对象即可创建相应的对象 .

  1.     /** Allocate an instance but do not run any constructor.
  2.         Initializes the class if it has not yet been. */
  3.     public native Object allocateInstance(Class<?> cls)
  4.         throws InstantiationException;

使用示例：

Employe类的唯一构造方法被私有化，外界不能直接创建此类的对象。但通过”Constructor.setAccessible(true)”将私有构造器设为外部可访问，使用反射机制也能创建一个Employee对象。

  1. package other;
  3. import sun.misc.Unsafe;
  4. import java.lang.reflect.Field;
  6. public class Employee {
  7.     private static int count;
  8.     private static long countL=1000;
  9.     private long id;
  10.     private String name;
  11.     private int sex;// 1代表男性，0代表女性
  12.     private long mgrId=11111;
  13.     static {
  14.         count = 1000;//目前员工人数的基数
  15.     }
  16.     private Employee() {
  17.         sex = 1;//默认为男性
  18.         name = "";
  19.         count++;
  20.         countL++;
  21.     }
  22.     @Override
  23.     public String toString() {
  24.         return "{Employee [id=" + id + ", name=" + name + ", sex=" + sex + ", mgrId=" + mgrId
  25.                 + "]}"+" ,{count="+count+", countLong="+countL+"}";
  26.     }
  27. }
  28. class EmployeeTest {
  29.     private static final Unsafe UNSAFE;
  30.     static {
  31.         try {
  32.             Field f = Unsafe.class.getDeclaredField("theUnsafe");
  33.             f.setAccessible(true);
  34.             UNSAFE = (Unsafe) f.get(null);
  35.         } catch (Exception e) {
  36.             throw new Error(e);
  37.         }
  38.     }
  39.     public static void main(String[] args) throws Exception {
  40.         Employee employee = (Employee) UNSAFE.allocateInstance(Employee.class);
  41.         System.out.println(employee);
  43. /*        Class<Employee> clazz = Employee.class;
  44.         Constructor<Employee> constructor = clazz.getDeclaredConstructor();
  45.         constructor.setAccessible(true);
  46.         Employee emp = constructor.newInstance();
  47.         System.out.println(emp);*/
  48.     }
  49. }

两种方式创建的对象toString()信息

Unsafe创建的对象 Java Unsafe类详解 - 图8
反射创建的对象 Java Unsafe类详解 - 图9

从上面的控制台输出信息可以看出，反射与Unsafe能均创建一个构造方法被私有化的对象。不同之处在于allocateInstance(Class)方法创建对象过程中不会进行对象初始化，但会进行类初始化；即不会执行实例变量初始化赋值、不执行构造代码块、不调用构造方法，但会执行静态变量的初始化赋值、执行静态代码块。

4 CAS更新操作

CAS是Java并发编程的最底层依据，它实现了非阻塞式地更新共享变量，自旋锁与乐观锁的实现均依赖它。

  1.  /**
  2.      * CAS更新共享变量
  3.      *
  4.      * @param o        字段所属对象
  5.      * @param offset   字段的相对偏移量
  6.      * @param expected 预期值
  7.      * @param x        更新值
  8.      * @return 更新成功则返回true
  9.      */
  10.     public final native boolean compareAndSwapObject(Object o, long offset, Object expected, Object x);
  12.     public final native boolean compareAndSwapInt(Object o, long offset, int expected, int x);
  14.     public final native boolean compareAndSwapLong(Object o, long offset, long expected, long x);

使用示例：
同步器AQS的compareAndSetXxx()方法都直接委托上面的CAS方法实现的

Java Unsafe类详解 - 图10

5 内存操作

根据内存地址，设置/获取对应的值

  1.    /**
  2.      *  参数address是绝对内存地址，参数x是设定的值
  3.      *  如果address是零或不是通过allocMemery()方法分配的地址，那么结果未定义
  4.      */
  5.     public native byte    getByte(long address);
  6.     public native void    putByte(long address, byte x);
  7.     /** @see #getByte(long) */
  8.     public native short   getShort(long address);
  9.     /** @see #putByte(long, byte) */
  10.     public native void    putShort(long address, short x);
  11.     /** @see #getByte(long) */
  12.     public native char    getChar(long address);
  13.     /** @see #putByte(long, byte) */
  14.     public native void    putChar(long address, char x);
  15.     /** @see #getByte(long) */
  16.     public native int     getInt(long address);
  17.     /** @see #putByte(long, byte) */
  18.     public native void    putInt(long address, int x);
  19.     /** @see #getByte(long) */
  20.     public native long    getLong(long address);
  21.     /** @see #putByte(long, byte) */
  22.     public native void    putLong(long address, long x);
  23.     /** @see #getByte(long) */
  24.     public native float   getFloat(long address);
  25.     /** @see #putByte(long, byte) */
  26.     public native void    putFloat(long address, float x);
  27.     /** @see #getByte(long) */
  28.     public native double  getDouble(long address);
  29.     /** @see #putByte(long, byte) */
  30.     public native void    putDouble(long address, double x);

根据内存地址设置/获取指针

  1.     //根据内存地址获取一个指针
  2.     public native long getAddress(long address);
  4.     //根据内存地址设置一个指针，adress是内存地址，x是指定的指针值
  5.     public native void putAddress(long address, long x);

分配、扩展、释放内存

  1.    //分配一块指定的内存空间，返回一个指向此内存起始位置的指针
  2.     public native long allocateMemory(long bytes);
  4.     //扩展内存
  5.     public native long reallocateMemory(long address, long bytes);
  7.     //在指定的内存块填充值
  8.     public native void setMemory(Object o, long offset, long bytes, byte value);
  10.     public void setMemory(long address, long bytes, byte value) {
  11.         setMemory(null, address, bytes, value);
  12.     }
  13.     //将一处内存的数据复制另一处内存
  14.     public native void copyMemory(Object srcBase, long srcOffset,
  15.                                   Object destBase, long destOffset,
  16.                                   long bytes);
  17.     public void copyMemory(long srcAddress, long destAddress, long bytes) {
  18.         copyMemory(null, srcAddress, null, destAddress, bytes);
  19.     }
  20.     //释放内存
  21.     public native void freeMemory(long address);

使用示例：

java.nio包下的DirectByteBuffer类的构造方法调用Unsafe.allocateMemory(int)分配初始条件下的的内存缓冲区

Java Unsafe类详解 - 图11

DirectByteBuffer的静态内部类Deallocator的run()调用Unsafe.freeMemory(long)释放相应地址的内存空间

Java Unsafe类详解 - 图12

6 系统信息

获取指定宽度、内存页大小等系统软硬件信息，这些信息对于本地内存的分配、使用、寻址很重要。

  1.     //本地指针宽度，通常是4或8
  2.     public native int addressSize();
  4.     /**
  5.      *内存页的大小，它总是2的幂次方
  6.      */
  7.     public native int pageSize();

使用示例：

sun.nio.ch包下NativeObject类的addressSize（）方法直接委托Unsafe.addressSize()实现

Java Unsafe类详解 - 图13

java.nio包下Bit类pageSize()方法:当pageSize非法时，将Unsafe.pageSize()作为返回值

Java Unsafe类详解 - 图14

可以看出addressSize()、 pageSize()方法的调用者都是nio相关类，这是因为nio是直接使用JVM堆外的本地内存。

7 线程管理

唤醒/休眠线程

  1.     public native void unpark(Object thread);//唤醒
  3.     public native void park(boolean isAbsolute, long time);//休眠

以上两个方法是”等待/通知模型”的关键，它们的并发编程中常使用到的底层方法。以上两个方法主要被LockSupport类直接引用，LockSupport.parkUtil(long) 、 LockSupport.upark(Thread)方法中没有其他逻辑，就是直接委托以上两个方法实现的。

使用示例：

Java Unsafe类详解 - 图15

抢锁与释放锁（已经被弃用）

  1.    //获取锁对象
  2.     @Deprecated
  3.     public native void monitorEnter(Object o);
  4.     //释放锁对象
  5.     @Deprecated
  6.     public native void monitorExit(Object o);
  7.     //尝试获取锁对象
  8.     @Deprecated
  9.     public native boolean tryMonitorEnter(Object o);

8 内存屏障

在Java 8中引入，用于定义内存屏障（也称内存栅栏，内存栅障，屏障指令等，是一类同步屏障指令，是CPU或编译器在对内存随机访问的操作中的一个同步点，使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作），避免代码重排序

  1.     /**
  2.      * 内存屏障，禁止load重排序。屏障前不能重排序load,且只能在屏障后load或store
  3.      */
  4.     public native void loadFence();
  6.     /**
  7.      * 内存屏障，禁止store重排序。 屏障前不能重排序store操作,且只能在屏障后load或store
  8.      */
  9.     public native void storeFence();
  11.     /**
  12.      * 内存屏障，禁止store load重排序。
  13.      */
  14.     public native void fullFence();

使用示例：

loadFence()方法在StampedLock的validate方法有使用到，StampedLock是为了防止CAS更新时出现ABA问题而在JDK1.8新引入的并发工具。

Java Unsafe类详解 - 图16

OpenJDK1.8中含注释的Unsafe类源代码

  1. /*
  2.  * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
  3.  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4.  *
  5.  * This code is free software; you can redistribute it and/or modify it
  6.  * under the terms of the GNU General Public License version 2 only, as
  7.  * published by the Free Software Foundation.  Oracle designates this
  8.  * particular file as subject to the "Classpath" exception as provided
  9.  * by Oracle in the LICENSE file that accompanied this code.
  10.  *
  11.  * This code is distributed in the hope that it will be useful, but WITHOUT
  12.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13.  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14.  * version 2 for more details (a copy is included in the LICENSE file that
  15.  * accompanied this code).
  16.  *
  17.  * You should have received a copy of the GNU General Public License version
  18.  * 2 along with this work; if not, write to the Free Software Foundation,
  19.  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20.  *
  21.  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22.  * or visit www.oracle.com if you need additional information or have any
  23.  * questions.
  24.  */
  26. package sun.misc;
  28. import java.security.*;
  29. import java.lang.reflect.*;
  31. import sun.reflect.CallerSensitive;
  32. import sun.reflect.Reflection;
  34. /**
  35.  * A collection of methods for performing low-level, unsafe operations.
  36.  * Although the class and all methods are public, use of this class is
  37.  * limited because only trusted code can obtain instances of it.
  38.  *
  39.  * @author John R. Rose
  40.  * @see #getUnsafe
  41.  */
  43. public final class Unsafe {
  45.     private static native void registerNatives();
  46.     static {
  47.         registerNatives();
  48.         sun.reflect.Reflection.registerMethodsToFilter(Unsafe.class, "getUnsafe");
  49.     }
  51.     private Unsafe() {}
  53.     private static final Unsafe theUnsafe = new Unsafe();
  55.     /**
  56.      * Provides the caller with the capability of performing unsafe
  57.      * operations.
  58.      *
  59.      * <p> The returned <code>Unsafe</code> object should be carefully guarded
  60.      * by the caller, since it can be used to read and write data at arbitrary
  61.      * memory addresses.  It must never be passed to untrusted code.
  62.      *
  63.      * <p> Most methods in this class are very low-level, and correspond to a
  64.      * small number of hardware instructions (on typical machines).  Compilers
  65.      * are encouraged to optimize these methods accordingly.
  66.      *
  67.      * <p> Here is a suggested idiom for using unsafe operations:
  68.      *
  69.      * <blockquote>
  70. <pre>
  71.      * class MyTrustedClass {
  72.      *   private static final Unsafe unsafe = Unsafe.getUnsafe();
  73.      *   ...
  74.      *   private long myCountAddress = ...;
  75.      *   public int getCount() { return unsafe.getByte(myCountAddress); }
  76.      * }
  77.      * </pre></blockquote>
  78.      *
  79.      * (It may assist compilers to make the local variable be
  80.      * <code>final</code>.)
  81.      *
  82.      * @exception  SecurityException  if a security manager exists and its
  83.      *             <code>checkPropertiesAccess</code> method doesn't allow
  84.      *             access to the system properties.
  85.      */
  86.     @CallerSensitive
  87.     public static Unsafe getUnsafe() {
  88.         Class<?> caller = Reflection.getCallerClass();
  89.         if (!VM.isSystemDomainLoader(caller.getClassLoader()))
  90.             throw new SecurityException("Unsafe");
  91.         return theUnsafe;
  92.     }
  94.     /// peek and poke operations
  95.     /// (compilers should optimize these to memory ops)
  97.     // These work on object fields in the Java heap.
  98.     // They will not work on elements of packed arrays.
  100.     /**
  101.      * Fetches a value from a given Java variable.
  102.      * More specifically, fetches a field or array element within the given
  103.      * object <code>o</code> at the given offset, or (if <code>o</code> is
  104.      * null) from the memory address whose numerical value is the given
  105.      * offset.
  106.      * <p>
  107.      * The results are undefined unless one of the following cases is true:
  108.      * <ul>
  109.      * <li>The offset was obtained from {@link #objectFieldOffset} on
  110.      * the {@link java.lang.reflect.Field} of some Java field and the object
  111.      * referred to by <code>o</code> is of a class compatible with that
  112.      * field's class.
  113.      *
  114.      * <li>The offset and object reference <code>o</code> (either null or
  115.      * non-null) were both obtained via {@link #staticFieldOffset}
  116.      * and {@link #staticFieldBase} (respectively) from the
  117.      * reflective {@link Field} representation of some Java field.
  118.      *
  119.      * <li>The object referred to by <code>o</code> is an array, and the offset
  120.      * is an integer of the form <code>B+N*S</code>, where <code>N</code> is
  121.      * a valid index into the array, and <code>B</code> and <code>S</code> are
  122.      * the values obtained by {@link #arrayBaseOffset} and {@link
  123.      * #arrayIndexScale} (respectively) from the array's class.  The value
  124.      * referred to is the <code>N</code><em>th</em> element of the array.
  125.      *
  126.      * </ul>
  127.      * <p>
  128.      * If one of the above cases is true, the call references a specific Java
  129.      * variable (field or array element).  However, the results are undefined
  130.      * if that variable is not in fact of the type returned by this method.
  131.      * <p>
  132.      * This method refers to a variable by means of two parameters, and so
  133.      * it provides (in effect) a <em>double-register</em> addressing mode
  134.      * for Java variables.  When the object reference is null, this method
  135.      * uses its offset as an absolute address.  This is similar in operation
  136.      * to methods such as {@link #getInt(long)}, which provide (in effect) a
  137.      * <em>single-register</em> addressing mode for non-Java variables.
  138.      * However, because Java variables may have a different layout in memory
  139.      * from non-Java variables, programmers should not assume that these
  140.      * two addressing modes are ever equivalent.  Also, programmers should
  141.      * remember that offsets from the double-register addressing mode cannot
  142.      * be portably confused with longs used in the single-register addressing
  143.      * mode.
  144.      *
  145.      * @param o Java heap object in which the variable resides, if any, else
  146.      *        null
  147.      * @param offset indication of where the variable resides in a Java heap
  148.      *        object, if any, else a memory address locating the variable
  149.      *        statically
  150.      * @return the value fetched from the indicated Java variable
  151.      * @throws RuntimeException No defined exceptions are thrown, not even
  152.      *         {@link NullPointerException}
  153.      */
  154.     public native int getInt(Object o, long offset);
  156.     /**
  157.      * Stores a value into a given Java variable.
  158.      * <p>
  159.      * The first two parameters are interpreted exactly as with
  160.      * {@link #getInt(Object, long)} to refer to a specific
  161.      * Java variable (field or array element).  The given value
  162.      * is stored into that variable.
  163.      * <p>
  164.      * The variable must be of the same type as the method
  165.      * parameter <code>x</code>.
  166.      *
  167.      * @param o Java heap object in which the variable resides, if any, else
  168.      *        null
  169.      * @param offset indication of where the variable resides in a Java heap
  170.      *        object, if any, else a memory address locating the variable
  171.      *        statically
  172.      * @param x the value to store into the indicated Java variable
  173.      * @throws RuntimeException No defined exceptions are thrown, not even
  174.      *         {@link NullPointerException}
  175.      */
  176.     public native void putInt(Object o, long offset, int x);
  178.     /**
  179.      * Fetches a reference value from a given Java variable.
  180.      * @see #getInt(Object, long)
  181.      */
  182.     public native Object getObject(Object o, long offset);
  184.     /**
  185.      * Stores a reference value into a given Java variable.
  186.      * <p>
  187.      * Unless the reference <code>x</code> being stored is either null
  188.      * or matches the field type, the results are undefined.
  189.      * If the reference <code>o</code> is non-null, car marks or
  190.      * other store barriers for that object (if the VM requires them)
  191.      * are updated.
  192.      * @see #putInt(Object, int, int)
  193.      */
  194.     public native void putObject(Object o, long offset, Object x);
  196.     /** @see #getInt(Object, long) */
  197.     public native boolean getBoolean(Object o, long offset);
  198.     /** @see #putInt(Object, int, int) */
  199.     public native void    putBoolean(Object o, long offset, boolean x);
  200.     /** @see #getInt(Object, long) */
  201.     public native byte    getByte(Object o, long offset);
  202.     /** @see #putInt(Object, int, int) */
  203.     public native void    putByte(Object o, long offset, byte x);
  204.     /** @see #getInt(Object, long) */
  205.     public native short   getShort(Object o, long offset);
  206.     /** @see #putInt(Object, int, int) */
  207.     public native void    putShort(Object o, long offset, short x);
  208.     /** @see #getInt(Object, long) */
  209.     public native char    getChar(Object o, long offset);
  210.     /** @see #putInt(Object, int, int) */
  211.     public native void    putChar(Object o, long offset, char x);
  212.     /** @see #getInt(Object, long) */
  213.     public native long    getLong(Object o, long offset);
  214.     /** @see #putInt(Object, int, int) */
  215.     public native void    putLong(Object o, long offset, long x);
  216.     /** @see #getInt(Object, long) */
  217.     public native float   getFloat(Object o, long offset);
  218.     /** @see #putInt(Object, int, int) */
  219.     public native void    putFloat(Object o, long offset, float x);
  220.     /** @see #getInt(Object, long) */
  221.     public native double  getDouble(Object o, long offset);
  222.     /** @see #putInt(Object, int, int) */
  223.     public native void    putDouble(Object o, long offset, double x);
  225.     /**
  226.      * This method, like all others with 32-bit offsets, was native
  227.      * in a previous release but is now a wrapper which simply casts
  228.      * the offset to a long value.  It provides backward compatibility
  229.      * with bytecodes compiled against 1.4.
  230.      * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
  231.      * See {@link #staticFieldOffset}.
  232.      */
  233.     @Deprecated
  234.     public int getInt(Object o, int offset) {
  235.         return getInt(o, (long)offset);
  236.     }
  238.     /**
  239.      * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
  240.      * See {@link #staticFieldOffset}.
  241.      */
  242.     @Deprecated
  243.     public void putInt(Object o, int offset, int x) {
  244.         putInt(o, (long)offset, x);
  245.     }
  247.     /**
  248.      * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
  249.      * See {@link #staticFieldOffset}.
  250.      */
  251.     @Deprecated
  252.     public Object getObject(Object o, int offset) {
  253.         return getObject(o, (long)offset);
  254.     }
  256.     /**
  257.      * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
  258.      * See {@link #staticFieldOffset}.
  259.      */
  260.     @Deprecated
  261.     public void putObject(Object o, int offset, Object x) {
  262.         putObject(o, (long)offset, x);
  263.     }
  265.     /**
  266.      * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
  267.      * See {@link #staticFieldOffset}.
  268.      */
  269.     @Deprecated
  270.     public boolean getBoolean(Object o, int offset) {
  271.         return getBoolean(o, (long)offset);
  272.     }
  274.     /**
  275.      * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
  276.      * See {@link #staticFieldOffset}.
  277.      */
  278.     @Deprecated
  279.     public void putBoolean(Object o, int offset, boolean x) {
  280.         putBoolean(o, (long)offset, x);
  281.     }
  283.     /**
  284.      * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
  285.      * See {@link #staticFieldOffset}.
  286.      */
  287.     @Deprecated
  288.     public byte getByte(Object o, int offset) {
  289.         return getByte(o, (long)offset);
  290.     }
  292.     /**
  293.      * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
  294.      * See {@link #staticFieldOffset}.
  295.      */
  296.     @Deprecated
  297.     public void putByte(Object o, int offset, byte x) {
  298.         putByte(o, (long)offset, x);
  299.     }
  301.     /**
  302.      * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
  303.      * See {@link #staticFieldOffset}.
  304.      */
  305.     @Deprecated
  306.     public short getShort(Object o, int offset) {
  307.         return getShort(o, (long)offset);
  308.     }
  310.     /**
  311.      * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
  312.      * See {@link #staticFieldOffset}.
  313.      */
  314.     @Deprecated
  315.     public void putShort(Object o, int offset, short x) {
  316.         putShort(o, (long)offset, x);
  317.     }
  319.     /**
  320.      * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
  321.      * See {@link #staticFieldOffset}.
  322.      */
  323.     @Deprecated
  324.     public char getChar(Object o, int offset) {
  325.         return getChar(o, (long)offset);
  326.     }
  328.     /**
  329.      * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
  330.      * See {@link #staticFieldOffset}.
  331.      */
  332.     @Deprecated
  333.     public void putChar(Object o, int offset, char x) {
  334.         putChar(o, (long)offset, x);
  335.     }
  337.     /**
  338.      * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
  339.      * See {@link #staticFieldOffset}.
  340.      */
  341.     @Deprecated
  342.     public long getLong(Object o, int offset) {
  343.         return getLong(o, (long)offset);
  344.     }
  346.     /**
  347.      * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
  348.      * See {@link #staticFieldOffset}.
  349.      */
  350.     @Deprecated
  351.     public void putLong(Object o, int offset, long x) {
  352.         putLong(o, (long)offset, x);
  353.     }
  355.     /**
  356.      * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
  357.      * See {@link #staticFieldOffset}.
  358.      */
  359.     @Deprecated
  360.     public float getFloat(Object o, int offset) {
  361.         return getFloat(o, (long)offset);
  362.     }
  364.     /**
  365.      * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
  366.      * See {@link #staticFieldOffset}.
  367.      */
  368.     @Deprecated
  369.     public void putFloat(Object o, int offset, float x) {
  370.         putFloat(o, (long)offset, x);
  371.     }
  373.     /**
  374.      * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
  375.      * See {@link #staticFieldOffset}.
  376.      */
  377.     @Deprecated
  378.     public double getDouble(Object o, int offset) {
  379.         return getDouble(o, (long)offset);
  380.     }
  382.     /**
  383.      * @deprecated As of 1.4.1, cast the 32-bit offset argument to a long.
  384.      * See {@link #staticFieldOffset}.
  385.      */
  386.     @Deprecated
  387.     public void putDouble(Object o, int offset, double x) {
  388.         putDouble(o, (long)offset, x);
  389.     }
  391.     // These work on values in the C heap.
  393.     /**
  394.      * Fetches a value from a given memory address.  If the address is zero, or
  395.      * does not point into a block obtained from {@link #allocateMemory}, the
  396.      * results are undefined.
  397.      *
  398.      * @see #allocateMemory
  399.      */
  400.     public native byte    getByte(long address);
  402.     /**
  403.      * Stores a value into a given memory address.  If the address is zero, or
  404.      * does not point into a block obtained from {@link #allocateMemory}, the
  405.      * results are undefined.
  406.      *
  407.      * @see #getByte(long)
  408.      */
  409.     public native void    putByte(long address, byte x);
  411.     /** @see #getByte(long) */
  412.     public native short   getShort(long address);
  413.     /** @see #putByte(long, byte) */
  414.     public native void    putShort(long address, short x);
  415.     /** @see #getByte(long) */
  416.     public native char    getChar(long address);
  417.     /** @see #putByte(long, byte) */
  418.     public native void    putChar(long address, char x);
  419.     /** @see #getByte(long) */
  420.     public native int     getInt(long address);
  421.     /** @see #putByte(long, byte) */
  422.     public native void    putInt(long address, int x);
  423.     /** @see #getByte(long) */
  424.     public native long    getLong(long address);
  425.     /** @see #putByte(long, byte) */
  426.     public native void    putLong(long address, long x);
  427.     /** @see #getByte(long) */
  428.     public native float   getFloat(long address);
  429.     /** @see #putByte(long, byte) */
  430.     public native void    putFloat(long address, float x);
  431.     /** @see #getByte(long) */
  432.     public native double  getDouble(long address);
  433.     /** @see #putByte(long, byte) */
  434.     public native void    putDouble(long address, double x);
  436.     /**
  437.      * Fetches a native pointer from a given memory address.  If the address is
  438.      * zero, or does not point into a block obtained from {@link
  439.      * #allocateMemory}, the results are undefined.
  440.      *
  441.      * <p> If the native pointer is less than 64 bits wide, it is extended as
  442.      * an unsigned number to a Java long.  The pointer may be indexed by any
  443.      * given byte offset, simply by adding that offset (as a simple integer) to
  444.      * the long representing the pointer.  The number of bytes actually read
  445.      * from the target address maybe determined by consulting {@link
  446.      * #addressSize}.
  447.      *
  448.      * @see #allocateMemory
  449.      */
  450.     public native long getAddress(long address);
  452.     /**
  453.      * Stores a native pointer into a given memory address.  If the address is
  454.      * zero, or does not point into a block obtained from {@link
  455.      * #allocateMemory}, the results are undefined.
  456.      *
  457.      * <p> The number of bytes actually written at the target address maybe
  458.      * determined by consulting {@link #addressSize}.
  459.      *
  460.      * @see #getAddress(long)
  461.      */
  462.     public native void putAddress(long address, long x);
  464.     /// wrappers for malloc, realloc, free:
  466.     /**
  467.      * Allocates a new block of native memory, of the given size in bytes.  The
  468.      * contents of the memory are uninitialized; they will generally be
  469.      * garbage.  The resulting native pointer will never be zero, and will be
  470.      * aligned for all value types.  Dispose of this memory by calling {@link
  471.      * #freeMemory}, or resize it with {@link #reallocateMemory}.
  472.      *
  473.      * @throws IllegalArgumentException if the size is negative or too large
  474.      *         for the native size_t type
  475.      *
  476.      * @throws OutOfMemoryError if the allocation is refused by the system
  477.      *
  478.      * @see #getByte(long)
  479.      * @see #putByte(long, byte)
  480.      */
  481.     public native long allocateMemory(long bytes);
  483.     /**
  484.      * Resizes a new block of native memory, to the given size in bytes.  The
  485.      * contents of the new block past the size of the old block are
  486.      * uninitialized; they will generally be garbage.  The resulting native
  487.      * pointer will be zero if and only if the requested size is zero.  The
  488.      * resulting native pointer will be aligned for all value types.  Dispose
  489.      * of this memory by calling {@link #freeMemory}, or resize it with {@link
  490.      * #reallocateMemory}.  The address passed to this method may be null, in
  491.      * which case an allocation will be performed.
  492.      *
  493.      * @throws IllegalArgumentException if the size is negative or too large
  494.      *         for the native size_t type
  495.      *
  496.      * @throws OutOfMemoryError if the allocation is refused by the system
  497.      *
  498.      * @see #allocateMemory
  499.      */
  500.     public native long reallocateMemory(long address, long bytes);
  502.     /**
  503.      * Sets all bytes in a given block of memory to a fixed value
  504.      * (usually zero).
  505.      *
  506.      * <p>This method determines a block's base address by means of two parameters,
  507.      * and so it provides (in effect) a <em>double-register</em> addressing mode,
  508.      * as discussed in {@link #getInt(Object,long)}.  When the object reference is null,
  509.      * the offset supplies an absolute base address.
  510.      *
  511.      * <p>The stores are in coherent (atomic) units of a size determined
  512.      * by the address and length parameters.  If the effective address and
  513.      * length are all even modulo 8, the stores take place in 'long' units.
  514.      * If the effective address and length are (resp.) even modulo 4 or 2,
  515.      * the stores take place in units of 'int' or 'short'.
  516.      *
  517.      * @since 1.7
  518.      */
  519.     public native void setMemory(Object o, long offset, long bytes, byte value);
  521.     /**
  522.      * Sets all bytes in a given block of memory to a fixed value
  523.      * (usually zero).  This provides a <em>single-register</em> addressing mode,
  524.      * as discussed in {@link #getInt(Object,long)}.
  525.      *
  526.      * <p>Equivalent to <code>setMemory(null, address, bytes, value)</code>.
  527.      */
  528.     public void setMemory(long address, long bytes, byte value) {
  529.         setMemory(null, address, bytes, value);
  530.     }
  532.     /**
  533.      * Sets all bytes in a given block of memory to a copy of another
  534.      * block.
  535.      *
  536.      * <p>This method determines each block's base address by means of two parameters,
  537.      * and so it provides (in effect) a <em>double-register</em> addressing mode,
  538.      * as discussed in {@link #getInt(Object,long)}.  When the object reference is null,
  539.      * the offset supplies an absolute base address.
  540.      *
  541.      * <p>The transfers are in coherent (atomic) units of a size determined
  542.      * by the address and length parameters.  If the effective addresses and
  543.      * length are all even modulo 8, the transfer takes place in 'long' units.
  544.      * If the effective addresses and length are (resp.) even modulo 4 or 2,
  545.      * the transfer takes place in units of 'int' or 'short'.
  546.      *
  547.      * @since 1.7
  548.      */
  549.     public native void copyMemory(Object srcBase, long srcOffset,
  550.                                   Object destBase, long destOffset,
  551.                                   long bytes);
  552.     /**
  553.      * Sets all bytes in a given block of memory to a copy of another
  554.      * block.  This provides a <em>single-register</em> addressing mode,
  555.      * as discussed in {@link #getInt(Object,long)}.
  556.      *
  557.      * Equivalent to <code>copyMemory(null, srcAddress, null, destAddress, bytes)</code>.
  558.      */
  559.     public void copyMemory(long srcAddress, long destAddress, long bytes) {
  560.         copyMemory(null, srcAddress, null, destAddress, bytes);
  561.     }
  563.     /**
  564.      * Disposes of a block of native memory, as obtained from {@link
  565.      * #allocateMemory} or {@link #reallocateMemory}.  The address passed to
  566.      * this method may be null, in which case no action is taken.
  567.      *
  568.      * @see #allocateMemory
  569.      */
  570.     public native void freeMemory(long address);
  572.     /// random queries
  574.     /**
  575.      * This constant differs from all results that will ever be returned from
  576.      * {@link #staticFieldOffset}, {@link #objectFieldOffset},
  577.      * or {@link #arrayBaseOffset}.
  578.      */
  579.     public static final int INVALID_FIELD_OFFSET   = -1;
  581.     /**
  582.      * Returns the offset of a field, truncated to 32 bits.
  583.      * This method is implemented as follows:
  584.      * <blockquote>
  585. <pre>
  586.      * public int fieldOffset(Field f) {
  587.      *     if (Modifier.isStatic(f.getModifiers()))
  588.      *         return (int) staticFieldOffset(f);
  589.      *     else
  590.      *         return (int) objectFieldOffset(f);
  591.      * }
  592.      * </pre></blockquote>
  593.      * @deprecated As of 1.4.1, use {@link #staticFieldOffset} for static
  594.      * fields and {@link #objectFieldOffset} for non-static fields.
  595.      */
  596.     @Deprecated
  597.     public int fieldOffset(Field f) {
  598.         if (Modifier.isStatic(f.getModifiers()))
  599.             return (int) staticFieldOffset(f);
  600.         else
  601.             return (int) objectFieldOffset(f);
  602.     }
  604.     /**
  605.      * Returns the base address for accessing some static field
  606.      * in the given class.  This method is implemented as follows:
  607.      * <blockquote>
  608. <pre>
  609.      * public Object staticFieldBase(Class c) {
  610.      *     Field[] fields = c.getDeclaredFields();
  611.      *     for (int i = 0; i < fields.length; i++) {
  612.      *         if (Modifier.isStatic(fields[i].getModifiers())) {
  613.      *             return staticFieldBase(fields[i]);
  614.      *         }
  615.      *     }
  616.      *     return null;
  617.      * }
  618.      * </pre></blockquote>
  619.      * @deprecated As of 1.4.1, use {@link #staticFieldBase(Field)}
  620.      * to obtain the base pertaining to a specific {@link Field}.
  621.      * This method works only for JVMs which store all statics
  622.      * for a given class in one place.
  623.      */
  624.     @Deprecated
  625.     public Object staticFieldBase(Class<?> c) {
  626.         Field[] fields = c.getDeclaredFields();
  627.         for (int i = 0; i < fields.length; i++) {
  628.             if (Modifier.isStatic(fields[i].getModifiers())) {
  629.                 return staticFieldBase(fields[i]);
  630.             }
  631.         }
  632.         return null;
  633.     }
  635.     /**
  636.      * Report the location of a given field in the storage allocation of its
  637.      * class.  Do not expect to perform any sort of arithmetic on this offset;
  638.      * it is just a cookie which is passed to the unsafe heap memory accessors.
  639.      *
  640.      * <p>Any given field will always have the same offset and base, and no
  641.      * two distinct fields of the same class will ever have the same offset
  642.      * and base.
  643.      *
  644.      * <p>As of 1.4.1, offsets for fields are represented as long values,
  645.      * although the Sun JVM does not use the most significant 32 bits.
  646.      * However, JVM implementations which store static fields at absolute
  647.      * addresses can use long offsets and null base pointers to express
  648.      * the field locations in a form usable by {@link #getInt(Object,long)}.
  649.      * Therefore, code which will be ported to such JVMs on 64-bit platforms
  650.      * must preserve all bits of static field offsets.
  651.      * @see #getInt(Object, long)
  652.      */
  653.     public native long staticFieldOffset(Field f);
  655.     /**
  656.      * Report the location of a given static field, in conjunction with {@link
  657.      * #staticFieldBase}.
  658.      * <p>Do not expect to perform any sort of arithmetic on this offset;
  659.      * it is just a cookie which is passed to the unsafe heap memory accessors.
  660.      *
  661.      * <p>Any given field will always have the same offset, and no two distinct
  662.      * fields of the same class will ever have the same offset.
  663.      *
  664.      * <p>As of 1.4.1, offsets for fields are represented as long values,
  665.      * although the Sun JVM does not use the most significant 32 bits.
  666.      * It is hard to imagine a JVM technology which needs more than
  667.      * a few bits to encode an offset within a non-array object,
  668.      * However, for consistency with other methods in this class,
  669.      * this method reports its result as a long value.
  670.      * @see #getInt(Object, long)
  671.      */
  672.     public native long objectFieldOffset(Field f);
  674.     /**
  675.      * Report the location of a given static field, in conjunction with {@link
  676.      * #staticFieldOffset}.
  677.      * <p>Fetch the base "Object", if any, with which static fields of the
  678.      * given class can be accessed via methods like {@link #getInt(Object,
  679.      * long)}.  This value may be null.  This value may refer to an object
  680.      * which is a "cookie", not guaranteed to be a real Object, and it should
  681.      * not be used in any way except as argument to the get and put routines in
  682.      * this class.
  683.      */
  684.     public native Object staticFieldBase(Field f);
  686.     /**
  687.      * Detect if the given class may need to be initialized. This is often
  688.      * needed in conjunction with obtaining the static field base of a
  689.      * class.
  690.      * @return false only if a call to {@code ensureClassInitialized} would have no effect
  691.      */
  692.     public native boolean shouldBeInitialized(Class<?> c);
  694.     /**
  695.      * Ensure the given class has been initialized. This is often
  696.      * needed in conjunction with obtaining the static field base of a
  697.      * class.
  698.      */
  699.     public native void ensureClassInitialized(Class<?> c);
  701.     /**
  702.      * Report the offset of the first element in the storage allocation of a
  703.      * given array class.  If {@link #arrayIndexScale} returns a non-zero value
  704.      * for the same class, you may use that scale factor, together with this
  705.      * base offset, to form new offsets to access elements of arrays of the
  706.      * given class.
  707.      *
  708.      * @see #getInt(Object, long)
  709.      * @see #putInt(Object, long, int)
  710.      */
  711.     public native int arrayBaseOffset(Class<?> arrayClass);
  713.     /** The value of {@code arrayBaseOffset(boolean[].class)} */
  714.     public static final int ARRAY_BOOLEAN_BASE_OFFSET
  715.             = theUnsafe.arrayBaseOffset(boolean[].class);
  717.     /** The value of {@code arrayBaseOffset(byte[].class)} */
  718.     public static final int ARRAY_BYTE_BASE_OFFSET
  719.             = theUnsafe.arrayBaseOffset(byte[].class);
  721.     /** The value of {@code arrayBaseOffset(short[].class)} */
  722.     public static final int ARRAY_SHORT_BASE_OFFSET
  723.             = theUnsafe.arrayBaseOffset(short[].class);
  725.     /** The value of {@code arrayBaseOffset(char[].class)} */
  726.     public static final int ARRAY_CHAR_BASE_OFFSET
  727.             = theUnsafe.arrayBaseOffset(char[].class);
  729.     /** The value of {@code arrayBaseOffset(int[].class)} */
  730.     public static final int ARRAY_INT_BASE_OFFSET
  731.             = theUnsafe.arrayBaseOffset(int[].class);
  733.     /** The value of {@code arrayBaseOffset(long[].class)} */
  734.     public static final int ARRAY_LONG_BASE_OFFSET
  735.             = theUnsafe.arrayBaseOffset(long[].class);
  737.     /** The value of {@code arrayBaseOffset(float[].class)} */
  738.     public static final int ARRAY_FLOAT_BASE_OFFSET
  739.             = theUnsafe.arrayBaseOffset(float[].class);
  741.     /** The value of {@code arrayBaseOffset(double[].class)} */
  742.     public static final int ARRAY_DOUBLE_BASE_OFFSET
  743.             = theUnsafe.arrayBaseOffset(double[].class);
  745.     /** The value of {@code arrayBaseOffset(Object[].class)} */
  746.     public static final int ARRAY_OBJECT_BASE_OFFSET
  747.             = theUnsafe.arrayBaseOffset(Object[].class);
  749.     /**
  750.      * Report the scale factor for addressing elements in the storage
  751.      * allocation of a given array class.  However, arrays of "narrow" types
  752.      * will generally not work properly with accessors like {@link
  753.      * #getByte(Object, int)}, so the scale factor for such classes is reported
  754.      * as zero.
  755.      *
  756.      * @see #arrayBaseOffset
  757.      * @see #getInt(Object, long)
  758.      * @see #putInt(Object, long, int)
  759.      */
  760.     public native int arrayIndexScale(Class<?> arrayClass);
  762.     /** The value of {@code arrayIndexScale(boolean[].class)} */
  763.     public static final int ARRAY_BOOLEAN_INDEX_SCALE
  764.             = theUnsafe.arrayIndexScale(boolean[].class);
  766.     /** The value of {@code arrayIndexScale(byte[].class)} */
  767.     public static final int ARRAY_BYTE_INDEX_SCALE
  768.             = theUnsafe.arrayIndexScale(byte[].class);
  770.     /** The value of {@code arrayIndexScale(short[].class)} */
  771.     public static final int ARRAY_SHORT_INDEX_SCALE
  772.             = theUnsafe.arrayIndexScale(short[].class);
  774.     /** The value of {@code arrayIndexScale(char[].class)} */
  775.     public static final int ARRAY_CHAR_INDEX_SCALE
  776.             = theUnsafe.arrayIndexScale(char[].class);
  778.     /** The value of {@code arrayIndexScale(int[].class)} */
  779.     public static final int ARRAY_INT_INDEX_SCALE
  780.             = theUnsafe.arrayIndexScale(int[].class);
  782.     /** The value of {@code arrayIndexScale(long[].class)} */
  783.     public static final int ARRAY_LONG_INDEX_SCALE
  784.             = theUnsafe.arrayIndexScale(long[].class);
  786.     /** The value of {@code arrayIndexScale(float[].class)} */
  787.     public static final int ARRAY_FLOAT_INDEX_SCALE
  788.             = theUnsafe.arrayIndexScale(float[].class);
  790.     /** The value of {@code arrayIndexScale(double[].class)} */
  791.     public static final int ARRAY_DOUBLE_INDEX_SCALE
  792.             = theUnsafe.arrayIndexScale(double[].class);
  794.     /** The value of {@code arrayIndexScale(Object[].class)} */
  795.     public static final int ARRAY_OBJECT_INDEX_SCALE
  796.             = theUnsafe.arrayIndexScale(Object[].class);
  798.     /**
  799.      * Report the size in bytes of a native pointer, as stored via {@link
  800.      * #putAddress}.  This value will be either 4 or 8.  Note that the sizes of
  801.      * other primitive types (as stored in native memory blocks) is determined
  802.      * fully by their information content.
  803.      */
  804.     public native int addressSize();
  806.     /** The value of {@code addressSize()} */
  807.     public static final int ADDRESS_SIZE = theUnsafe.addressSize();
  809.     /**
  810.      * Report the size in bytes of a native memory page (whatever that is).
  811.      * This value will always be a power of two.
  812.      */
  813.     public native int pageSize();
  815.     /// random trusted operations from JNI:
  817.     /**
  818.      * Tell the VM to define a class, without security checks.  By default, the
  819.      * class loader and protection domain come from the caller's class.
  820.      */
  821.     public native Class<?> defineClass(String name, byte[] b, int off, int len,
  822.                                        ClassLoader loader,
  823.                                        ProtectionDomain protectionDomain);
  825.     /**
  826.      * Define a class but do not make it known to the class loader or system dictionary.
  827.      * <p>
  828.      * For each CP entry, the corresponding CP patch must either be null or have
  829.      * the a format that matches its tag:
  830.      * <ul>
  831.      * <li>Integer, Long, Float, Double: the corresponding wrapper object type from java.lang
  832.      * <li>Utf8: a string (must have suitable syntax if used as signature or name)
  833.      * <li>Class: any java.lang.Class object
  834.      * <li>String: any object (not just a java.lang.String)
  835.      * <li>InterfaceMethodRef: (NYI) a method handle to invoke on that call site's arguments
  836.      * </ul>
  837.      * @params hostClass context for linkage, access control, protection domain, and class loader
  838.      * @params data      bytes of a class file
  839.      * @params cpPatches where non-null entries exist, they replace corresponding CP entries in data
  840.      */
  841.     public native Class<?> defineAnonymousClass(Class<?> hostClass, byte[] data, Object[] cpPatches);
  843.     /** Allocate an instance but do not run any constructor.
  844.         Initializes the class if it has not yet been. */
  845.     public native Object allocateInstance(Class<?> cls)
  846.         throws InstantiationException;
  848.     /** Lock the object.  It must get unlocked via {@link #monitorExit}. */
  849.     @Deprecated
  850.     public native void monitorEnter(Object o);
  852.     /**
  853.      * Unlock the object.  It must have been locked via {@link
  854.      * #monitorEnter}.
  855.      */
  856.     @Deprecated
  857.     public native void monitorExit(Object o);
  859.     /**
  860.      * Tries to lock the object.  Returns true or false to indicate
  861.      * whether the lock succeeded.  If it did, the object must be
  862.      * unlocked via {@link #monitorExit}.
  863.      */
  864.     @Deprecated
  865.     public native boolean tryMonitorEnter(Object o);
  867.     /** Throw the exception without telling the verifier. */
  868.     public native void throwException(Throwable ee);
  870.     /**
  871.      * Atomically update Java variable to <tt>x</tt> if it is currently
  872.      * holding <tt>expected</tt>.
  873.      * @return <tt>true</tt> if successful
  874.      */
  875.     public final native boolean compareAndSwapObject(Object o, long offset,
  876.                                                      Object expected,
  877.                                                      Object x);
  879.     /**
  880.      * Atomically update Java variable to <tt>x</tt> if it is currently
  881.      * holding <tt>expected</tt>.
  882.      * @return <tt>true</tt> if successful
  883.      */
  884.     public final native boolean compareAndSwapInt(Object o, long offset,
  885.                                                   int expected,
  886.                                                   int x);
  888.     /**
  889.      * Atomically update Java variable to <tt>x</tt> if it is currently
  890.      * holding <tt>expected</tt>.
  891.      * @return <tt>true</tt> if successful
  892.      */
  893.     public final native boolean compareAndSwapLong(Object o, long offset,
  894.                                                    long expected,
  895.                                                    long x);
  897.     /**
  898.      * Fetches a reference value from a given Java variable, with volatile
  899.      * load semantics. Otherwise identical to {@link #getObject(Object, long)}
  900.      */
  901.     public native Object getObjectVolatile(Object o, long offset);
  903.     /**
  904.      * Stores a reference value into a given Java variable, with
  905.      * volatile store semantics. Otherwise identical to {@link #putObject(Object, long, Object)}
  906.      */
  907.     public native void    putObjectVolatile(Object o, long offset, Object x);
  909.     /** Volatile version of {@link #getInt(Object, long)}  */
  910.     public native int     getIntVolatile(Object o, long offset);
  912.     /** Volatile version of {@link #putInt(Object, long, int)}  */
  913.     public native void    putIntVolatile(Object o, long offset, int x);
  915.     /** Volatile version of {@link #getBoolean(Object, long)}  */
  916.     public native boolean getBooleanVolatile(Object o, long offset);
  918.     /** Volatile version of {@link #putBoolean(Object, long, boolean)}  */
  919.     public native void    putBooleanVolatile(Object o, long offset, boolean x);
  921.     /** Volatile version of {@link #getByte(Object, long)}  */
  922.     public native byte    getByteVolatile(Object o, long offset);
  924.     /** Volatile version of {@link #putByte(Object, long, byte)}  */
  925.     public native void    putByteVolatile(Object o, long offset, byte x);
  927.     /** Volatile version of {@link #getShort(Object, long)}  */
  928.     public native short   getShortVolatile(Object o, long offset);
  930.     /** Volatile version of {@link #putShort(Object, long, short)}  */
  931.     public native void    putShortVolatile(Object o, long offset, short x);
  933.     /** Volatile version of {@link #getChar(Object, long)}  */
  934.     public native char    getCharVolatile(Object o, long offset);
  936.     /** Volatile version of {@link #putChar(Object, long, char)}  */
  937.     public native void    putCharVolatile(Object o, long offset, char x);
  939.     /** Volatile version of {@link #getLong(Object, long)}  */
  940.     public native long    getLongVolatile(Object o, long offset);
  942.     /** Volatile version of {@link #putLong(Object, long, long)}  */
  943.     public native void    putLongVolatile(Object o, long offset, long x);
  945.     /** Volatile version of {@link #getFloat(Object, long)}  */
  946.     public native float   getFloatVolatile(Object o, long offset);
  948.     /** Volatile version of {@link #putFloat(Object, long, float)}  */
  949.     public native void    putFloatVolatile(Object o, long offset, float x);
  951.     /** Volatile version of {@link #getDouble(Object, long)}  */
  952.     public native double  getDoubleVolatile(Object o, long offset);
  954.     /** Volatile version of {@link #putDouble(Object, long, double)}  */
  955.     public native void    putDoubleVolatile(Object o, long offset, double x);
  957.     /**
  958.      * Version of {@link #putObjectVolatile(Object, long, Object)}
  959.      * that does not guarantee immediate visibility of the store to
  960.      * other threads. This method is generally only useful if the
  961.      * underlying field is a Java volatile (or if an array cell, one
  962.      * that is otherwise only accessed using volatile accesses).
  963.      */
  964.     public native void    putOrderedObject(Object o, long offset, Object x);
  966.     /** Ordered/Lazy version of {@link #putIntVolatile(Object, long, int)}  */
  967.     public native void    putOrderedInt(Object o, long offset, int x);
  969.     /** Ordered/Lazy version of {@link #putLongVolatile(Object, long, long)} */
  970.     public native void    putOrderedLong(Object o, long offset, long x);
  972.     /**
  973.      * Unblock the given thread blocked on <tt>park</tt>, or, if it is
  974.      * not blocked, cause the subsequent call to <tt>park</tt> not to
  975.      * block.  Note: this operation is "unsafe" solely because the
  976.      * caller must somehow ensure that the thread has not been
  977.      * destroyed. Nothing special is usually required to ensure this
  978.      * when called from Java (in which there will ordinarily be a live
  979.      * reference to the thread) but this is not nearly-automatically
  980.      * so when calling from native code.
  981.      * @param thread the thread to unpark.
  982.      *
  983.      */
  984.     public native void unpark(Object thread);
  986.     /**
  987.      * Block current thread, returning when a balancing
  988.      * <tt>unpark</tt> occurs, or a balancing <tt>unpark</tt> has
  989.      * already occurred, or the thread is interrupted, or, if not
  990.      * absolute and time is not zero, the given time nanoseconds have
  991.      * elapsed, or if absolute, the given deadline in milliseconds
  992.      * since Epoch has passed, or spuriously (i.e., returning for no
  993.      * "reason"). Note: This operation is in the Unsafe class only
  994.      * because <tt>unpark</tt> is, so it would be strange to place it
  995.      * elsewhere.
  996.      */
  997.     public native void park(boolean isAbsolute, long time);
  999.     /**
  1000.      * Gets the load average in the system run queue assigned
  1001.      * to the available processors averaged over various periods of time.
  1002.      * This method retrieves the given <tt>nelem</tt> samples and
  1003.      * assigns to the elements of the given <tt>loadavg</tt> array.
  1004.      * The system imposes a maximum of 3 samples, representing
  1005.      * averages over the last 1,  5,  and  15 minutes, respectively.
  1006.      *
  1007.      * @params loadavg an array of double of size nelems
  1008.      * @params nelems the number of samples to be retrieved and
  1009.      *         must be 1 to 3.
  1010.      *
  1011.      * @return the number of samples actually retrieved; or -1
  1012.      *         if the load average is unobtainable.
  1013.      */
  1014.     public native int getLoadAverage(double[] loadavg, int nelems);
  1016.     // The following contain CAS-based Java implementations used on
  1017.     // platforms not supporting native instructions
  1019.     /**
  1020.      * Atomically adds the given value to the current value of a field
  1021.      * or array element within the given object <code>o</code>
  1022.      * at the given <code>offset</code>.
  1023.      *
  1024.      * @param o object/array to update the field/element in
  1025.      * @param offset field/element offset
  1026.      * @param delta the value to add
  1027.      * @return the previous value
  1028.      * @since 1.8
  1029.      */
  1030.     public final int getAndAddInt(Object o, long offset, int delta) {
  1031.         int v;
  1032.         do {
  1033.             v = getIntVolatile(o, offset);
  1034.         } while (!compareAndSwapInt(o, offset, v, v + delta));
  1035.         return v;
  1036.     }
  1038.     /**
  1039.      * Atomically adds the given value to the current value of a field
  1040.      * or array element within the given object <code>o</code>
  1041.      * at the given <code>offset</code>.
  1042.      *
  1043.      * @param o object/array to update the field/element in
  1044.      * @param offset field/element offset
  1045.      * @param delta the value to add
  1046.      * @return the previous value
  1047.      * @since 1.8
  1048.      */
  1049.     public final long getAndAddLong(Object o, long offset, long delta) {
  1050.         long v;
  1051.         do {
  1052.             v = getLongVolatile(o, offset);
  1053.         } while (!compareAndSwapLong(o, offset, v, v + delta));
  1054.         return v;
  1055.     }
  1057.     /**
  1058.      * Atomically exchanges the given value with the current value of
  1059.      * a field or array element within the given object <code>o</code>
  1060.      * at the given <code>offset</code>.
  1061.      *
  1062.      * @param o object/array to update the field/element in
  1063.      * @param offset field/element offset
  1064.      * @param newValue new value
  1065.      * @return the previous value
  1066.      * @since 1.8
  1067.      */
  1068.     public final int getAndSetInt(Object o, long offset, int newValue) {
  1069.         int v;
  1070.         do {
  1071.             v = getIntVolatile(o, offset);
  1072.         } while (!compareAndSwapInt(o, offset, v, newValue));
  1073.         return v;
  1074.     }
  1076.     /**
  1077.      * Atomically exchanges the given value with the current value of
  1078.      * a field or array element within the given object <code>o</code>
  1079.      * at the given <code>offset</code>.
  1080.      *
  1081.      * @param o object/array to update the field/element in
  1082.      * @param offset field/element offset
  1083.      * @param newValue new value
  1084.      * @return the previous value
  1085.      * @since 1.8
  1086.      */
  1087.     public final long getAndSetLong(Object o, long offset, long newValue) {
  1088.         long v;
  1089.         do {
  1090.             v = getLongVolatile(o, offset);
  1091.         } while (!compareAndSwapLong(o, offset, v, newValue));
  1092.         return v;
  1093.     }
  1095.     /**
  1096.      * Atomically exchanges the given reference value with the current
  1097.      * reference value of a field or array element within the given
  1098.      * object <code>o</code> at the given <code>offset</code>.
  1099.      *
  1100.      * @param o object/array to update the field/element in
  1101.      * @param offset field/element offset
  1102.      * @param newValue new value
  1103.      * @return the previous value
  1104.      * @since 1.8
  1105.      */
  1106.     public final Object getAndSetObject(Object o, long offset, Object newValue) {
  1107.         Object v;
  1108.         do {
  1109.             v = getObjectVolatile(o, offset);
  1110.         } while (!compareAndSwapObject(o, offset, v, newValue));
  1111.         return v;
  1112.     }
  1114.     /**
  1115.      * Ensures lack of reordering of loads before the fence
  1116.      * with loads or stores after the fence.
  1117.      * @since 1.8
  1118.      */
  1119.     public native void loadFence();
  1121.     /**
  1122.      * Ensures lack of reordering of stores before the fence
  1123.      * with loads or stores after the fence.
  1124.      * @since 1.8
  1125.      */
  1126.     public native void storeFence();
  1128.     /**
  1129.      * Ensures lack of reordering of loads or stores before the fence
  1130.      * with loads or stores after the fence.
  1131.      * @since 1.8
  1132.      */
  1133.     public native void fullFence();
  1135.     /**
  1136.      * Throws IllegalAccessError; for use by the VM.
  1137.      * @since 1.8
  1138.      */
  1139.     private static void throwIllegalAccessError() {
  1140.        throw new IllegalAccessError();
  1141.     }
  1143. }