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();也可以达到相同的效果。

作者：mayifan_blog

来源：CSDN