聊聊高并发（十七）解析java.util.concurrent各个组件（一） 了解sun.misc.Unsafe类

了解了并发编程中锁的基本原理之后，接下来看看Java是如何利用这些原理来实现各种锁，原子变量，同步组件的。在开始分析java.util.concurrent的源代码直接，首先要了解的就是sun.misc.Unsafe类，这个类可以说的java并发包的基础，基本上所有的组件都是依赖Unsafe来做底层的同步操作。

Unsafe类有100+个方法，大部分是native方法，可以理解为Java平台和底层操作系统直接的桥梁。它封装了大量的底层操作，比如直接操作内存的方法，低级同步的方法，CAS方法，直接操作Class的方法，直接操作Object的方法等等。有了Unsafe类，就可以像C, C++一样精确地操作内存。当然Java的一大优点就是可以安全的操作内存，所以不提倡开发者直接使用Unsafe类。JDK本身的类很多都利用了Unsafe来进行底层操作。

Unsafe和并发编程相关的有几类方法:

1. CAS方法

2. 操作条件队列的方法，比如park()让线程进入等待，unpark()唤醒线程

3. 存取volatile变量的方法，比如getBooleanVolatile, putBooleanVolatile

首先看看CAS方法，主要是3个comAndSwapXXX方法

1. compareAndSwapObject提供了对一个对象引用进行CAS的能力

2. compareAndSwapInt提供了对一个32位整数进行CAS操作的能力

3. compareAndSwapLong提供了对64位整数进行CAS操作的能力

关于CAS的概念请看这篇 聊聊高并发（十二）分析java.util.concurrent.atomic.AtomicStampedReference源码来看如何解决CAS的ABA问题

public final class Unsafe{   

    public final native boolean compareAndSwapObject(Object o, long offset,
                                                     Object expected,
                                                     Object x);

    /**
     * Atomically update Java variable to <tt>x</tt> if it is currently
     * holding <tt>expected</tt>.
     * @return <tt>true</tt> if successful
     */
    public final native boolean compareAndSwapInt(Object o, long offset,
                                                  int expected,
                                                  int x);

    /**
     * Atomically update Java variable to <tt>x</tt> if it is currently
     * holding <tt>expected</tt>.
     * @return <tt>true</tt> if successful
     */
    public final native boolean compareAndSwapLong(Object o, long offset,
                                                   long expected,
                                                   long x);

..............
}

操作条件队列的方法有两个：

1. park(boolean isAbsolute, long time), 这个方法会让当前线程进入等待，并释放锁。Java并发包里的Condition接口的底层实现就是利用了Unsafe的park方法来实现的。第一个参数isAbsolute是表示用绝对时间还是相对事件，如果是绝对时间，就等待直到time，比如Condition接口的awaitUntil(Date deadline)。isAbsolute为false时，等待一个时间间隔

2. unpark(Object thread)唤醒等待的线程，Condition的signal方法就是基于unpark实现的

/**
     * Unblock the given thread blocked on <tt>park</tt>, or, if it is
     * not blocked, cause the subsequent call to <tt>park</tt> not to
     * block.  Note: this operation is "unsafe" solely because the
     * caller must somehow ensure that the thread has not been
     * destroyed. Nothing special is usually required to ensure this
     * when called from Java (in which there will ordinarily be a live
     * reference to the thread) but this is not nearly-automatically
     * so when calling from native code.
     * @param thread the thread to unpark.
     *
     */
    public native void unpark(Object thread);

    /**
     * Block current thread, returning when a balancing
     * <tt>unpark</tt> occurs, or a balancing <tt>unpark</tt> has
     * already occurred, or the thread is interrupted, or, if not
     * absolute and time is not zero, the given time nanoseconds have
     * elapsed, or if absolute, the given deadline in milliseconds
     * since Epoch has passed, or spuriously (i.e., returning for no
     * "reason"). Note: This operation is in the Unsafe class only
     * because <tt>unpark</tt> is, so it would be strange to place it
     * elsewhere.
     */
    public native void park(boolean isAbsolute, long time);

存取volatile变量的方法，这些方法让Unsafe对象有了直接存取volatile变量的能力。

public native Object getObjectVolatile(Object obj, long l);

    public native void putObjectVolatile(Object obj, long l, Object obj1);

    public native int getIntVolatile(Object obj, long l);

    public native void putIntVolatile(Object obj, long l, int i);

    public native boolean getBooleanVolatile(Object obj, long l);

    public native void putBooleanVolatile(Object obj, long l, boolean flag);

    public native byte getByteVolatile(Object obj, long l);

    public native void putByteVolatile(Object obj, long l, byte byte0);

    public native short getShortVolatile(Object obj, long l);

    public native void putShortVolatile(Object obj, long l, short word0);

    public native char getCharVolatile(Object obj, long l);

    public native void putCharVolatile(Object obj, long l, char c);

    public native long getLongVolatile(Object obj, long l);

    public native void putLongVolatile(Object obj, long l, long l1);

    public native float getFloatVolatile(Object obj, long l);

    public native void putFloatVolatile(Object obj, long l, float f);

    public native double getDoubleVolatile(Object obj, long l);

    public native void putDoubleVolatile(Object obj, long l, double d);

关于Unsafe对象的其他信息，比如如何得到Unsafe对象，比如如何直接操作内存，类似反射机制存取对象属性，请查看这篇 Java Magic 4. Part 4: sun.misc,Unsafe

java.util.concurrent包提供了一个LockSupport类来封装了Unsafe对象，来提供操作条件队列的方法。

来看一下LockSupport的实现，有几点比较有意思

1. 利用Unsafe直接操作内存来存取对象的能力来设置blocker

Unsafe.objectFieldOffset可以获得某个字段在对象所在内存的offset，有了这个offset，就可以通过对象的引用来找到字段所在的实际内存地址。这种做法在C++中常见，但是在Java中不推荐上层程序使用。

这段代码的意思是把arg对象设置到Thread的parkBlocker属性上。

Thread的parkBlocker属性用来指出当前线程是在哪个对象上阻塞

public class LockSupport {
    private LockSupport() {} // Cannot be instantiated.

    // Hotspot implementation via intrinsics API
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long parkBlockerOffset;

    static {
        try {
            parkBlockerOffset = unsafe.objectFieldOffset
                (java.lang.Thread.class.getDeclaredField("parkBlocker"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private static void setBlocker(Thread t, Object arg) {
        // Even though volatile, hotspot doesn't need a write barrier here.
        unsafe.putObject(t, parkBlockerOffset, arg);
    }


public class Thread{
 /**
     * The argument supplied to the current call to
     * java.util.concurrent.locks.LockSupport.park.
     * Set by (private) java.util.concurrent.locks.LockSupport.setBlocker
     * Accessed using java.util.concurrent.locks.LockSupport.getBlocker
     */
    volatile Object parkBlocker;
} 

2. park方法需要指明锁对象，可以看到，park方法先setBlocker标记当前线程是在哪个锁对象上等待，然后调用Unsafe的park方法，当Unsafe的park方法返回时表示已经退出等待，就把blocker设置为null.

用jstack命令查看过线程状态的同学肯定知道jstack能打印出线程是在哪个对象上block，这个对象就是这里的blocker

public static void park(Object blocker) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        unsafe.park(false, 0L);
        setBlocker(t, null);
    }

LockSupport的park()和unpark()方法和Object.wait(), notify方法都可以操作线程的等待和唤醒，但是两者主要有两个区别

1. 面向的主体不同，LockSupport的park, unpark面向的是线程，而Object.wait, nofify面向的是对象

2. 底层实现机制不同，可以看到Object的wait, notify方法也是native方法，Unsafe的park和unpark方法也是native方法，底层实现不同，Object.notify不能唤醒Unsafe park的线程。

public class Object{
    public final native void wait(long timeout) throws InterruptedException;
   
    public final native void notify();

    public final native void notifyAll();
}