Java的LockSupport工具，Condition接口和ConditionObject

在之前我们文章（关于多线程编程基础和同步器），我们就接触到了LockSupport工具和Condition接口，之前使用LockSupport工具来唤醒阻塞的线程，使用Condition接口来实现线程的等待和唤醒和Object方法里面的wait方法和notify方法。接下来我们就LockSupport和Condition进行展开：

1. LockSupport
2. Condition
3. ConditionObject

---

LockSupport

在说LockSupport之前我们有必要说一下Unsafe类，这个类可以进行一些原子操作（CAS），和一些非常有用但是我们的Java又不允许的操作。对于本文我们只需要知道Unsafe可以进行阻塞和唤醒操作，当然它的功能不知这些，参考了别人的文章发现自己再写相关的介绍好多余，特别推荐我给出的第一篇来自importNew的文章，里面介绍的很细致！

下面给出介绍Unsafe比较好的文章：

http://www.importnew.com/14511.html

https://www.cnblogs.com/mickole/articles/3757278.html

https://www.cnblogs.com/pkufork/p/java_unsafe.html

Unsafe类的作用：

以下的介绍出自https://www.cnblogs.com/pkufork/p/java_unsafe.html（加粗以示强调，侵删）

一、内存管理。包括分配内存、释放内存等。

该部分包括了allocateMemory（分配内存）、reallocateMemory（重新分配内存）、copyMemory（拷贝内存）、freeMemory（释放内存 ）、getAddress（获取内存地址）、addressSize、pageSize、getInt（获取内存地址指向的整数）、getIntVolatile（获取内存地址指向的整数，并支持volatile语义）、putInt（将整数写入指定内存地址）、putIntVolatile（将整数写入指定内存地址，并支持volatile语义）、putOrderedInt（将整数写入指定内存地址、有序或者有延迟的方法）等方法。getXXX和putXXX包含了各种基本类型的操作。

利用copyMemory方法，我们可以实现一个通用的对象拷贝方法，无需再对每一个对象都实现clone方法，当然这通用的方法只能做到对象浅拷贝。

二、非常规的对象实例化。

allocateInstance()方法提供了另一种创建实例的途径。通常我们可以用new或者反射来实例化对象，使用allocateInstance()方法可以直接生成对象实例，且无需调用构造方法和其它初始化方法。

这在对象反序列化的时候会很有用，能够重建和设置final字段，而不需要调用构造方法。

三、操作类、对象、变量。

这部分包括了staticFieldOffset（静态域偏移）、defineClass（定义类）、defineAnonymousClass（定义匿名类）、ensureClassInitialized（确保类初始化）、objectFieldOffset（对象域偏移）等方法。

通过这些方法我们可以获取对象的指针，通过对指针进行偏移，我们不仅可以直接修改指针指向的数据（即使它们是私有的），甚至可以找到JVM已经认定为垃圾、可以进行回收的对象。

四、数组操作。

这部分包括了arrayBaseOffset（获取数组第一个元素的偏移地址）、arrayIndexScale（获取数组中元素的增量地址）等方法。arrayBaseOffset与arrayIndexScale配合起来使用，就可以定位数组中每个元素在内存中的位置。

由于Java的数组最大值为Integer.MAX_VALUE，使用Unsafe类的内存分配方法可以实现超大数组。实际上这样的数据就可以认为是C数组，因此需要注意在合适的时间释放内存。

五、多线程同步。包括锁机制、CAS操作等。

这部分包括了monitorEnter、tryMonitorEnter、monitorExit、compareAndSwapInt、compareAndSwap等方法。

其中monitorEnter、tryMonitorEnter、monitorExit已经被标记为deprecated，不建议使用。

Unsafe类的CAS操作可能是用的最多的，它为Java的锁机制提供了一种新的解决办法，比如AtomicInteger等类都是通过该方法来实现的。compareAndSwap方法是原子的，可以避免繁重的锁机制，提高代码效率。这是一种乐观锁，通常认为在大部分情况下不出现竞态条件，如果操作失败，会不断重试直到成功。

六、挂起与恢复。

这部分包括了park、unpark等方法。

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

七、内存屏障。

这部分包括了loadFence、storeFence、fullFence等方法。这是在Java 8新引入的，用于定义内存屏障，避免代码重排序。

loadFence() 表示该方法之前的所有load操作在内存屏障之前完成。同理storeFence()表示该方法之前的所有store操作在内存屏障之前完成。fullFence()表示该方法之前的所有load、store操作在内存屏障之前完成。

本篇文章我们仅需要知道它是可以进行阻塞唤醒操作的即可：

下面我们继续说LockSupport：

整个LockSupport类并不大（注释很多，很全面，赞），加上大批量的注释也就400行出头，里面最主要的就是调用Unsafe的方法，所以很简洁！

package java.util.concurrent.locks;
import sun.misc.Unsafe;

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

    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 static void unpark(Thread thread) {
        if (thread != null)
            UNSAFE.unpark(thread);
    }

	//阻塞调用此方法的线程，这个的参数是阻塞对象，用来表示当前线程在等待的对象，
	//用于排查和系统监控（这个在Java6后添加的，同期还添加了parkNanos方法和parkUtil方法，里面都含有blocker参数）
    public static void park(Object blocker) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(false, 0L);
        setBlocker(t, null);
    }
	//阻塞当前线程最长不超过nanos纳秒
    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);
        }
    }

	//阻塞当前线程直到deadline
    public static void parkUntil(Object blocker, long deadline) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        UNSAFE.park(true, deadline);
        setBlocker(t, null);
    }

	//获取阻塞对象
    public static Object getBlocker(Thread t) {
        if (t == null)
            throw new NullPointerException();
        return UNSAFE.getObjectVolatile(t, parkBlockerOffset);
    }

    //阻塞线程
    public static void park() {
        UNSAFE.park(false, 0L);
    }

    //阻塞当前线程最长不超过nanos纳秒
    public static void parkNanos(long nanos) {
        if (nanos > 0)
            UNSAFE.park(false, nanos);
    }

	//阻塞当前线程直到deadline（无阻塞对象参数）
    public static void parkUntil(long deadline) {
        UNSAFE.park(true, deadline);
    }

    static final int nextSecondarySeed() {
        int r;
        Thread t = Thread.currentThread();
        if ((r = UNSAFE.getInt(t, SECONDARY)) != 0) {
            r ^= r << 13;   // xorshift
            r ^= r >>> 17;
            r ^= r << 5;
        }
        else if ((r = java.util.concurrent.ThreadLocalRandom.current().nextInt()) == 0)
            r = 1; // avoid zero
        UNSAFE.putInt(t, SECONDARY, r);
        return r;
    }

    // Hotspot implementation via intrinsics API
    private static final sun.misc.Unsafe UNSAFE;
    private static final long parkBlockerOffset;
    private static final long SEED;
    private static final long PROBE;
    private static final long SECONDARY;
    static {
        try {
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class<?> tk = Thread.class;
            parkBlockerOffset = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("parkBlocker"));
            SEED = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("threadLocalRandomSeed"));
            PROBE = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("threadLocalRandomProbe"));
            SECONDARY = UNSAFE.objectFieldOffset
                (tk.getDeclaredField("threadLocalRandomSecondarySeed"));
        } catch (Exception ex) { throw new Error(ex); }
    }
}

上面的代码我们会发现又两种版本的，有blocker参数和无blocker参数，这个参数是用来当代码出问题的时候，我们dump出等待对象的信息，在Java6推出的Lock等并发工具遗漏了这些功能，所以Java6进行了补充，所以有blocker参数的方法可以替代原来无blocker参数的方法！

---

Condition

所有的Java对象都有监视器方法（在Object上），有wait（），wait（long timeout），notify（），notifyAll（），这些方法在使用的时候往往配合着synchronized使用，来完成等待通知，Condition接口也提供了类似的方法接口，例如await（），signal（）。

它可以实现多个等待队列，并且支持当前线程释放锁并进入等待状态，在等待状态中不响应中断和当前线程释放锁进入等待状态到将来的某个时间（这是之前，现在的Object对象是可以释放锁到将来的某个时间的）。

Condition接口代码：

public interface Condition {

	//当前线程进入等待状态，直到被通知或中断
    void await() throws InterruptedException;

	//当前线程进入等待状态，直到被通知或中断（对中断不敏感）
    void awaitUninterruptibly();

	//当前线程进入等待状态，直到被通知，中断或超时
    long awaitNanos(long nanosTimeout) throws InterruptedException;

	//当前线程进入等待状态，直到被通知，中断或超时（注意这个返回值是boolean）
    boolean await(long time, TimeUnit unit) throws InterruptedException;

	//当前线程进入等待状态，直到被通知，中断或到某个时间
    boolean awaitUntil(Date deadline) throws InterruptedException;

	//唤醒一个在Condition上的线程
    void signal();

	//唤醒所有在Condition上的线程
    void signalAll();
}

那么Condition怎么来获取：

	Lock lock = new ReentrantLock();
	Condition c = lock.newCondition();

newCondition是Lock接口内定义的方法，后面每个实现Lock的接口都会实现这个方法。

但是Lock的实现方法里面一般不会自己提供newCondition方法而是这样：

 public Condition newCondition() {
        return sync.newCondition();
    }

 final ConditionObject newCondition() {
            return new ConditionObject();
    }

通过new ConditionObject来创建Condition实例，所以可以说ConditionObject是Condition接口的主要实现类：

 public class ConditionObject implements Condition,
 java.io.Serializable {
	 .
	 .
	 .
}

值得一说的是，额，这个ConditionObject 类是写在AbstractQueuedSynchronizer内部的，但是好像并不是它的内部类（可能是考虑到用户可以自定义一个同步组件），我在书上看（《并发编程的艺术》）上面写ConditionObject 是AbstractQueuedSynchronizer内部类（可能版本更新，将ConditionObject外置了吧）。

---

ConditionObject

其实在之前写关于同步器文章的时候就应该包含这个，为此还被大神鄙视了一番，没有详尽的分析源码，这里补上。

所以这里值得讨论的就不再是Condition接口了，而是它的实现类ConditionObject。

除了实现Condition接口里面的一些方法，ConditionObject也添加了一些监视和控制的工具方法，我们主要分析Condition的await和notify方法。

ConditionObject维持了一个等待队列，和之前我们描述的同步队列结构类似，简直可以照搬过来使用。



上面是同步队列，下面是等待队列。

当调用await方法的时候，这时当前线程一定获取了与这个condition对象对应的锁了，当调用await方法的时候同样等同于同步队列的首节点移动到了等待队列当中。

接下来看看ConditionObject的结构：

命名：

 public class ConditionObject implements Condition,
 java.io.Serializable {
 {

字段

	//头结点和尾节点
    private transient Node firstWaiter;
    private transient Node lastWaiter;

构造函数：

  public ConditionObject() { }

主要方法：

我们从await方法开始：

    public final void await() throws InterruptedException {
            //当前线程中断抛出异常
            if (Thread.interrupted())
                throw new InterruptedException();
            //为调用await 方法创建节点
            Node node = addConditionWaiter();
            //释放同步状态，fullyRelease里面会调用释放方法，
            //同时唤醒同步队列的下一个节点
            int savedState = fullyRelease(node);
            //下面是对监控变量做的改变
            int interruptMode = 0;
            //如果节点不在同步队列中
            while (!isOnSyncQueue(node)) {
                LockSupport.park(this);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            //只有成功获取锁后，调用await方法的线程才能用await方法返回
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }

private Node addConditionWaiter() {
            //获取尾节点
            Node t = lastWaiter;
            // If lastWaiter is cancelled, clean out.
            if (t != null && t.waitStatus != Node.CONDITION) {
                unlinkCancelledWaiters();
                t = lastWaiter;
            }
            //为线程创建新节点
            Node node = new Node(Thread.currentThread(), Node.CONDITION);
            if (t == null)
                firstWaiter = node;
            else
                t.nextWaiter = node;
            lastWaiter = node;
            //返回这个新节点
            return node;
        }

唤醒方法：

  public final void signal() {
			//如果当前线程未获取锁，抛出异常
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            //获取同步队列的首节点
            Node first = firstWaiter;
            //如果头结点不为空，那么将它移动到同步队列并使用LockSupport唤醒
            if (first != null)
                doSignal(first);
        }

  private void doSignal(Node first) {
            do {
                if ( (firstWaiter = first.nextWaiter) == null)
                    lastWaiter = null;
                first.nextWaiter = null;
                //transferForSignal方法将等待队列节点重新包装成Node节点
                //加入同步队列
            } while (!transferForSignal(first) &&
                     (first = firstWaiter) != null);
        }

signalAll方法和上面的signal方法雷同，就是通知等待队列中的每一个节点，将它们移动到等待队列中。

当一个节点被唤醒后，加入同步队列中，将从await方法中的while循环（isOnSyncQueue）返回，进而调用acquireQueued方法加入获取同步状态的行列中。

到这里关于锁的学习就结束了，AQS真的是博大精深，自知自己学习的还是不到位，仅仅是明白了一些简单基本的原理，以后还会花时间去深入的看！

如有错误欢迎指正，不胜感激！

2018.3.30 11：10