🔔🔔好消息!好消息!🔔🔔

目录

• 一、前言

• 二、底层native方法（底层C++不拓展了）

• 三、上层应用方法（调用了native方法实现）

正文

尽管有传言JAVA9可能会移除Unsafe类，但不妨碍我们理解它的原理。因为类不在了，native方法还在那里。就像菜换样了，食材就那些没变。一个好厨师不仅仅需要会做菜，还需要能识别食材特性...来吧，直接上干货。

注：强烈不建议程序中自己调用Unsafe类方法，这一点没有质疑。

目录

1.前言

2.Unsafe中的native方法

3.Unsafe中的上层方法

=======正文分割线======

一、前言

在JDK8中追踪可见sun.misc.Unsafe这个类是无法看见源码的，打开openjdk8源码看

目录：openjdk-8-src-b132-03_mar_2014\openjdk\jdk\src\share\classes\sun\misc

此类包含了低级（native硬件级别的原子操作）、不安全的操作集合。

获取Unsafe实例静态方法：

private Unsafe() {}

private static final Unsafe theUnsafe = new Unsafe();

@CallerSensitive
public static Unsafe getUnsafe() {
    Class<?> caller = Reflection.getCallerClass();
    if (!VM.isSystemDomainLoader(caller.getClassLoader()))
        throw new SecurityException("Unsafe");
    return theUnsafe;
}

二、底层native方法（底层C++不拓展了）

共计82个public native,下面列出了核心方法：

 //扩充内存  
    public native long reallocateMemory(long address, long bytes);  
      
    //分配内存  
    public native long allocateMemory(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);  
      
    //获取值，不管java的访问限制，其他有类似的getInt，getDouble，getLong，getChar等等  
    public native Object getObject(Object o, long offset);  
      
    //设置值，不管java的访问限制，其他有类似的putInt,putDouble，putLong，putChar等等  
    public native void putObject(Object o, long offset);  
      
    //从一个给定的内存地址获取本地指针，如果不是allocateMemory方法的，结果将不确定  
    public native long getAddress(long address);  
      
    //存储一个本地指针到一个给定的内存地址,如果地址不是allocateMemory方法的，结果将不确定  
    public native void putAddress(long address, long x);  
      
    //该方法返回给定field的内存地址偏移量，这个值对于给定的filed是唯一的且是固定不变的  
    public native long staticFieldOffset(Field f);  
      
    //报告一个给定的字段的位置，不管这个字段是private，public还是保护类型，和staticFieldBase结合使用  
    public native long objectFieldOffset(Field f);  
      
    //获取一个给定字段的位置  
    public native Object staticFieldBase(Field f);  
      
    //确保给定class被初始化，这往往需要结合基类的静态域（field）  
    public native void ensureClassInitialized(Class c);  
      
    //可以获取数组第一个元素的偏移地址  
    public native int arrayBaseOffset(Class arrayClass);  
      
    //可以获取数组的转换因子，也就是数组中元素的增量地址。将arrayBaseOffset与arrayIndexScale配合使用， 可以定位数组中每个元素在内存中的位置  
    public native int arrayIndexScale(Class arrayClass);  
      
    //获取本机内存的页数，这个值永远都是2的幂次方  
    public native int pageSize();  
      
    //告诉虚拟机定义了一个没有安全检查的类，默认情况下这个类加载器和保护域来着调用者类  
    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);  
      
    //锁定对象，必须是没有被锁的
    public native void monitorEnter(Object o);  
      
    //解锁对象  
    public native void monitorExit(Object o);  
      
    //试图锁定对象，返回true或false是否锁定成功，如果锁定，必须用monitorExit解锁  
    public native boolean tryMonitorEnter(Object o);  
      
    //引发异常，没有通知  
    public native void throwException(Throwable ee);  
      
    //CAS，如果对象偏移量上的值=期待值，更新为x,返回true.否则false.类似的有compareAndSwapInt,compareAndSwapLong,compareAndSwapBoolean,compareAndSwapChar等等。  
    public final native boolean compareAndSwapObject(Object o, long offset,  Object expected, Object x);  
      
    // 该方法获取对象中offset偏移地址对应的整型field的值,支持volatile load语义。类似的方法有getIntVolatile，getBooleanVolatile等等  
    public native Object getObjectVolatile(Object o, long offset);   
      
    //线程调用该方法，线程将一直阻塞直到超时，或者是中断条件出现。  
    public native void park(boolean isAbsolute, long time);  
      
    //终止挂起的线程，恢复正常.java.util.concurrent包中挂起操作都是在LockSupport类实现的，也正是使用这两个方法
    public native void unpark(Object thread);  
      
    //获取系统在不同时间系统的负载情况  
    public native int getLoadAverage(double[] loadavg, int nelems);  
      
    //创建一个类的实例，不需要调用它的构造函数、初使化代码、各种JVM安全检查以及其它的一些底层的东西。即使构造函数是私有，我们也可以通过这个方法创建它的实例,对于单例模式，简直是噩梦，哈哈  
    public native Object allocateInstance(Class cls) throws InstantiationException;

三、上层应用方法（调用了native方法实现）

3.1 原子CAS操作

如果对象内存地址偏移量上的数值不变，更改为新值

 /**
     * Atomically exchanges the given reference value with the current
     * reference value of a field or array element within the given
     * object <code>o</code> at the given <code>offset</code>.
     *
     * @param o object/array to update the field/element in
     * @param offset field/element offset
     * @param newValue new value
     * @return the previous value
     * @since 1.8
     */
    public final Object getAndSetObject(Object o, long offset, Object newValue) {
        Object v;
        do {
            v = getObjectVolatile(o, offset);//获取对象内存地址偏移量上的数值v
        } while (!compareAndSwapObject(o, offset, v, newValue));//如果现在还是v,设置为newValue,否则返回false,！false=true，一直循环直到等于v退出循环返回v.
        return v;
    }

 C++代码CAS：

static inline bool
compareAndSwap (volatile jint *addr, jint old, jint new_val)
{
  jboolean result = false;
  spinlock lock;
  if ((result = (*addr == old)))
    *addr = new_val;
  return result;
}

====参考========

1.openjdk8源码

2.Java中Unsafe类详解

3.并行编程(1) - sum.msic.Unsafe 一