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