Java Unsafe类的使用

Unsafe类的作用

Unsafe类是rt.jar包中的类，它提供了原子级别的操作，它的方法都是native方法，通过JNI访问本地的C++库。它的出现是为了解决在高并发下的数据同步问题。synchronize关键字修饰的代码块被加了独占锁，相同时间只能有一个线程访问其中的内容，在高并发下这必然会导致大量线程挂起，从用户态转为内核态，带来很大的消耗而且操作效率低下。CAS算法的出现使得在不使用synchronize这种“悲观锁”依然可以实现数据的安全访问，CAS算法是指先读取要修改的变量值，对它进行计算，然后执行检查并更新这个步骤(更新前判断那个值是否是之前那个读到的值)，检查并更新是个原子操作，它由硬件来保证可靠性，CAS算法的最后一步的方法就是Unsafe类的方法。因此，Unsafe类的方法可以说是Java高并发的各种扩展类的基础，他们的底层都是调用Unsafe类的方法，Unsafe类为各种扩展类提供底层的原子操作。

Unsafe类的加载和使用

Unsafe类是rt.jar包中的类，rt包是通过顶层的类加载器Bootstrap类加载器加载的。如果不是在Bootstrap类加载器加载的类中试图加载这个类,JVM就会报错。比如我尝试在自己创建的TestUnsafe类中用Unsafe使用getUnsafe()方法获取实例，就会报错。如果一定要使用它，需要使用万能的反射机制。代码如下：

public class TestUnsafe {

//获取Unsafe实例

static final Unsafe unsafe;

//记录state在类TestUsafe中的偏移值

static final long stateOffset;

//变量

public volatile long result=0;

public int[] arr={1,2,3,4,5,6};

static{

try{

//获取成员变量

Field field=Unsafe.class.getDeclaredField("theUnsafe");

//设置为可访问

field.setAccessible(true);

//是静态字段,用null来获取Unsafe实例

unsafe=(Unsafe)field.get(null);

//获取state变量在类中的偏移值

stateOffset=unsafe.objectFieldOffset(TestUnsafe.class.getDeclaredField("result"));

}catch(Exception e){

System.out.println(e.getLocalizedMessage());

throw new Error(e);

}

}

public static void main(String[] args){

TestUnsafe testUnsafe=new TestUnsafe();

//执行并返回结果

for(int i=0;i<1000;i++)

unsafe.getAndAddLong(testUnsafe,stateOffset ,3L);

System.out.println(testUnsafe.result);

System.out.println(unsafe.arrayBaseOffset(testUnsafe.arr.getClass()));

System.out.println(unsafe.arrayIndexScale(testUnsafe.arr.getClass()));

System.out.println(unsafe.compareAndSwapLong(testUnsafe, stateOffset, 3000, 4000));

System.out.println(unsafe.getLongVolatile(testUnsafe, stateOffset));

unsafe.putLongVolatile(testUnsafe, stateOffset, 5000);

System.out.println(testUnsafe.result);

unsafe.putOrderedLong(testUnsafe, stateOffset, 5500);

System.out.println(testUnsafe.result);

Thread thread1=new Thread(){

public void run(){

System.out.println("线程1开始沉睡");

long start=System.currentTimeMillis();

long end=System.currentTimeMillis()+8000;

unsafe.park(true,end);

System.out.println("主线程在"+(System.currentTimeMillis()-start)+"ms后被线程2唤醒");

}

};

Thread thread2=new Thread(){

public void run(){

try {

sleep(3000);

unsafe.unpark(thread1);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

};

thread1.start();

thread2.start();

}

}

输出 ：

分析

：在上面的代码中我做了这样一件事。在题目中用static申明了Unsafe实例，long类型的变量偏移量，可见的long变量result。在一段static代码中使用反射获取Unsafe的实例，设置为可访问并使用实例来获取result变量的偏移量，因为这些是静态的，所以在类加载的时候这些事情都做完了。接下来我调用了unsafe的

getAndAddLong(testUnsafe,stateOffset

,3L);方法对变量reslut进行了1000次的加3操作，最终输出结果是3000。

unsafe.getAndAddLong(testUnsafe,stateOffset ,3L);方法

：这是一个原子操作，输入是参数是所在的类对象，变量在内存中的偏移量，加多少(3L表示加3，L表示这是一个long类型的变量)。“偏移量”这个参数就足够体现出这是一个原子操作了，直接对指定位置赋值。

stateOffset=unsafe.objectFieldOffset(TestUnsafe.class.getDeclaredField(“result”));方法

：这个方法是获取指定成员变量在内存中的偏移地址，参数是Field，这里必须通过反射机制获取。

unsafe.arrayBaseOffset(testUnsafe.arr.getClass())方法 ：获取数组中第一个元素的地址。

unsafe.arrayIndexScale(testUnsafe.arr.getClass())方法 ：获取数组中一个元素占用的字节。

unsafe.compareAndSwapLong(testUnsafe, stateOffset, 3000, 4000)方法

：比较并更新。比较指定偏移量下的变量值是否和3000这个expect值相等，如果相等则把它更新为4000，这是原子操作，由硬件提供可靠性。

unsafe.getLongVolatile(testUnsafe, stateOffset)方法

：获取指定对象中某偏移量下的volatile值，这里需要输入一个对象是因为，在多个对象的情况下，每个对象都是被分配存储空间的，因此，指定对象下的某个变量才是唯一的。

unsafe.putLongVolatile(testUnsafe, stateOffset, 5000);方法

：设置指定对象某偏移量下的long类型的field值为5000，支持volatile语义。

unsafe.putOrderedLong(testUnsafe, stateOffset, 5500);方法

：作用和上面这个方法一样，只是它是一个有延迟的putLongVolatile方法，对变量的修改不会对别的线程立刻可见，一般在希望在这期间变量被意外修改才使用它。

unsafe.park(true,end);方法

：阻塞当前线程一段时间。true表示绝对时间(单位ms)，false表示相对时间(单位ns)，当false和0作为输入时表示一直阻塞。

unsafe.unpark(thread1);方法 ：唤醒指定线程。thread1.interrupt();也可以达到相同的效果。

原文链接：https://blog.csdn.net/mayifan_blog/article/details/86777656