ReentrantLock 源码分析(二)

关于 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.  这个类是用于执行低级别、不安全操作的方法集合。尽管这个类和所有的方法都是公开的（public），但是这个类的使用仍然受限，你无法在自己的java程序中直接使用该类，因为只有授信的代码才能获得该类的实例

 

为何变得不安全

sun.misc.Unsafe这个类是如此地不安全，以至于JDK开发者增加了很多特殊限制来访问它。它的构造器是私有的，工厂方法getUnsafe()的调用器只能被Bootloader加载。如你在下面代码片段的第8行所见，这个家伙甚至没有被任何类加载器加载，所以它的类加载器是null。它会抛出SecurityException 异常来阻止侵入者。

 

public final class Unsafe {
   ...
   private Unsafe() {}
   private static final Unsafe theUnsafe = new Unsafe();
   ...
   public static Unsafe getUnsafe() {
      Class cc = sun.reflect.Reflection.getCallerClass(2);
      if (cc.getClassLoader() != null)
          throw new SecurityException("Unsafe");
      return theUnsafe;
   }
   ...
}

 幸运的是这里有一个Unsafe的变量可以被用来取得Unsafe的实例。我们可以轻松地编写一个复制方法通过反射来实现，如下所示：

public static Unsafe getUnsafe() {
   try {
           Field f = Unsafe.class.getDeclaredField("theUnsafe");
           f.setAccessible(true);
           return (Unsafe)f.get(null);
   } catch (Exception e) {
       /* ... */
   }
}

 

java不能直接访问操作系统底层，而是通过本地方法来访问。Unsafe类提供了硬件级别的原子操作，主要提供了以下功能：

通过Unsafe类可以分配内存，可以释放内存

类中提供的3个本地方法allocateMemory、reallocateMemory、freeMemory分别用于分配内存，扩充内存和释放内存，与C语言中的3个方法对应。

 

可以定位对象某字段的内存位置，也可以修改对象的字段值，即使它是私有的

    public native long allocateMemory(long l);  
    public native long reallocateMemory(long l, long l1);  
    public native void freeMemory(long l);  

 

字段的定位：

JAVA中对象的字段的定位可能通过staticFieldOffset方法实现，该方法返回给定field的内存地址偏移量，这个值对于给定的filed是唯一的且是固定不变的。

getIntVolatile方法获取对象中offset偏移地址对应的整型field的值,支持volatile load语义。

getLong方法获取对象中offset偏移地址对应的long型field的值

数组元素定位：

Unsafe类中有很多以BASE_OFFSET结尾的常量，比如 ARRAY_INT_BASE_OFFSET，ARRAY_BYTE_BASE_OFFSET等，这些常量值是通过arrayBaseOffset方法得 到的。arrayBaseOffset方法是一个本地方法，可以获取数组第一个元素的偏移地址。Unsafe类中还有很多以INDEX_SCALE结尾的 常量，比如 ARRAY_INT_INDEX_SCALE ， ARRAY_BYTE_INDEX_SCALE等，这些常量值是通过arrayIndexScale方法得到的。arrayIndexScale方法 也是一个本地方法，可以获取数组的转换因子，也就是数组中元素的增量地址。将arrayBaseOffset与arrayIndexScale配合使用， 可以定位数组中每个元素在内存中的位置。

public static final int ARRAY_INT_BASE_OFFSET;  
    public static final int ARRAY_INT_INDEX_SCALE;  
  
    public native long staticFieldOffset(Field field);  
    public native int getIntVolatile(Object obj, long l);  
    public native long getLong(Object obj, long l);  
    public native int arrayBaseOffset(Class class1);  
    public native int arrayIndexScale(Class class1);  
  
    static   
    {  
        ARRAY_INT_BASE_OFFSET = theUnsafe.arrayBaseOffset([I);  
        ARRAY_INT_INDEX_SCALE = theUnsafe.arrayIndexScale([I);  
    }  

 

挂起与恢复

将一个线程进行挂起是通过park方法实现的，调用 park后，线程将一直阻塞直到超时或者中断等条件出现。unpark可以终止一个挂起的线程，使其恢复正常。整个并发框架中对线程的挂起操作被封装在 LockSupport类中，LockSupport类中有各种版本pack方法，但最终都调用了Unsafe.park()方法。

    public class LockSupport {  
        public static void unpark(Thread thread) {  
            if (thread != null)  
                unsafe.unpark(thread);  
        }  
      
        public static void park(Object blocker) {  
            Thread t = Thread.currentThread();  
            setBlocker(t, blocker);  
            unsafe.park(false, 0L);  
            setBlocker(t, null);  
        }  
      
        public static void parkNanos(Object blocker, long nanos) {  
            if (nanos > 0) {  
                Thread t = Thread.currentThread();  
                setBlocker(t, blocker);  
                unsafe.park(false, nanos);  
                setBlocker(t, null);  
            }  
        }  
      
        public static void parkUntil(Object blocker, long deadline) {  
            Thread t = Thread.currentThread();  
            setBlocker(t, blocker);  
            unsafe.park(true, deadline);  
            setBlocker(t, null);  
        }  
      
        public static void park() {  
            unsafe.park(false, 0L);  
        }  
      
        public static void parkNanos(long nanos) {  
            if (nanos > 0)  
                unsafe.park(false, nanos);  
        }  
      
        public static void parkUntil(long deadline) {  
            unsafe.park(true, deadline);  
        }  
    }  

 

CAS操作

 

是通过compareAndSwapXXX方法实现的

    /** 
    * 比较obj的offset处内存位置中的值和期望的值，如果相同则更新。此更新是不可中断的。 
    *  
    * @param obj 需要更新的对象 
    * @param offset obj中整型field的偏移量 
    * @param expect 希望field中存在的值 
    * @param update 如果期望值expect与field的当前值相同，设置filed的值为这个新值 
    * @return 如果field的值被更改返回true 
    */  
    public native boolean compareAndSwapInt(Object obj, long offset, int expect, int update);  

 CAS操作有3个操作数，内存值M，预期值E，新值U，如果M==E，则将内存值修改为B，否则啥都不做。

 

http://mishadoff.com/blog/java-magic-part-4-sun-dot-misc-dot-unsafe/

http://www.docjar.com/html/api/sun/misc/Unsafe.java.html