ConditionObject

ConditionObject

1. 在JUC包下，ConditionObject为了对标Synchronized的wait()和notify()方法的功能，提供了await()和signal()方法。
2. 和Synchronized一样必须持lock锁才能调用await()和signal()方法
3. 它是基于AQS实现的，在AQS提供了一个单项链表来存储被挂起的线程，当调用await()时候将线程放到Condition链表中，当调用signal()方法时候将线程放到AQS的双向链表中。

基本使用

public class Test {
    public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        new Thread(() -> {
            try {
                lock.lock();
                System.out.println("线程1获取锁成功，休眠5S");
                Thread.sleep(5000);
                System.out.println("线程1挂起线程");
                condition.await();
                System.out.println("线程1线程被唤醒，操作结束,释放锁！");
                lock.unlock();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }).start();

        Thread.sleep(100);
        
        new Thread(() -> {
            try {
                lock.lock();
                System.out.println("线程2获取锁成功，休眠3S");
                Thread.sleep(3000);
                System.out.println("线程2执行完毕，释放锁，唤醒线程1");
                condition.signal();
                lock.unlock();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }).start();
    }
}

源码分析

Condition构建方法

1. 在ReentrantLock中的newCondition()方法中调用了其内部类Sync的newCondition()方法返回一个ConditionObject对象。
2. 本质就是返回一个AQS中的ConditionObject对象。
3. 一个ReentrantLock可以创建多个ConditionObject对象，在后面的阻塞队列中有用到，读和写使用两个ConditionObject对象，互不影响。

    public Condition newCondition() {
        return sync.newCondition();
    }
    final ConditionObject newCondition() {
        return new ConditionObject();
        }

ConditionObject类

1. firstWaiter和lastWaiter记录单项链表的头节点和尾节点
2. 用于存放节点信息的Node和AQS双向链表是同一个node类，其中只用nextWaiter属性表示节点关系
3. node节点中的 static final int CONDITION = -2; 表示当前节点被放入Condition单项链表中，挂起线程

   public class ConditionObject implements Condition, java.io.Serializable {
    private static final long serialVersionUID = 1173984872572414699L;
    //链表的头节点
    private transient Node firstWaiter;
    //链表的尾节点
    private transient Node lastWaiter;
    public ConditionObject() {
    }
}

await()挂起线程

      public final void await() throws InterruptedException {
            //线程被中断，抛出异常
            if (Thread.interrupted())
                throw new InterruptedException();
            //封装node并插入到Condition单项链表中
            Node node = addConditionWaiter();
            //释放锁
            int savedState = fullyRelease(node);
            //中断标记位置，这里有三种状态
            //0表示没有被中断
            //-1表示被中断唤醒
            //1表示被唤醒后唤醒
            int interruptMode = 0;
            //判断节点释放在AQS双向链表中
            while (!isOnSyncQueue(node)) {
                //如果不在，挂起线程
                LockSupport.park(this);
                //查看中断标记位置，如果被中断过checkInterruptWhileWaiting方法能证明已经在AQS双向链表中了，跳出循环
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            //尝试获取锁并且状态不是直接中断，将interruptMode改为1
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            //如果当前节点还在condition单项链表中，移除这个节点
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
            //如果线程被中断过，判断是直接中断还是被唤醒后中断，如果是被唤醒后中断判断中断标识位
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }
        
        //封装node节点并插入到condition单项链表中
        private Node addConditionWaiter() {
                //判断当前线程是不是持有锁的线程
                if (!isHeldExclusively())
                    throw new IllegalMonitorStateException();
                //拿到尾节点
                Node t = lastWaiter;
                //如果尾节点存在，且状态不为-2
                if (t != null && t.waitStatus != Node.CONDITION) {
                    unlinkCancelledWaiters();
                    //重新获取尾节点
                    t = lastWaiter;
                }
                //封装Node对象
                Node node = new Node(Node.CONDITION);
                //如果尾节点为null,将当前节点设置为尾节点
                if (t == null)
                    firstWaiter = node;
                else
                    //否则将当前节点挂到尾节点后面
                    t.nextWaiter = node;
                //未节点设置为当前节点
                lastWaiter = node;
                //返回封装的节点
                return node;
        }
        //判断节点释放在AQS双向链表中
        final boolean isOnSyncQueue(Node node) {
        //节点状态为-2或者在AQS双向链表中node的prev为null，证明没有在
        if (node.waitStatus == Node.CONDITION || node.prev == null)
            return false;
        //node有next证明在
        if (node.next != null) // If has successor, it must be on queue
            return true;
        //前面情况不能判断是不是在，遍历双向链表判断是不是在
        return findNodeFromTail(node);
        }
        //判断节点的状态是被正常唤醒还是中断唤醒还是唤醒后被中断
        private int checkInterruptWhileWaiting(Node node) {
            return Thread.interrupted() ?
                (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
                0;
        }
        //这里可以确定node已经在AQS双向链表中了，所以在wait的while循环中可以跳出循环
        final boolean transferAfterCancelledWait(Node node) {
            if (node.compareAndSetWaitStatus(Node.CONDITION, 0)) {
                enq(node);
                return true;
            }
            while (!isOnSyncQueue(node))
                Thread.yield();
            return false;
      }

signal()唤醒线程

1. 被唤醒的线程从condition单项链表中移除，在唤醒过程中将状态不为-2的节点也从链表中移除，直到找到一个可以被唤醒的节点。
2. 将唤醒的节点插入到AQS双向链表中

     //唤醒操作
     public final void signal() {
            //判断是否是持有锁的线程，如果不是抛出异常
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            //获取Condition单项链表的头节点
            Node first = firstWaiter;
            //如果有，唤醒操作
            if (first != null)
                doSignal(first);
        }
      //判断当前线程是不是持有锁的线程
     protected final boolean isHeldExclusively() {
        return getExclusiveOwnerThread() == Thread.currentThread();
        }
     //将头节点从链表中移除的操作 
     private void doSignal(Node first) {
        do {
            //将头节点设置为下一个节点，并且判断是不是null,如果头节点没有下一个节点了，将尾节点设置为 null
            if ( (firstWaiter = first.nextWaiter) == null)
                lastWaiter = null;
            //将传入的头节点的下个节点设置为null,从单线链表中移除，等待被GC
            first.nextWaiter = null;
        } 
        //如果唤醒失败，单向链表中还有可以被唤醒的节点，执行下次循环唤醒下个节点以此类推
        while (!transferForSignal(first) &&
            (first = firstWaiter) != null);
        }
    //唤醒操作
    final boolean transferForSignal(Node node) {
        //基于CAS将节点的waitStatus状态修改为0，即准备状态，等待被插入到AQS双向链表中
        if (!node.compareAndSetWaitStatus(Node.CONDITION, 0))
            //修改失败返回false
            return false;
        //修改成功，将当前节点插入到AQS双向链表中，这里返回的node是插入节点的前继节点
        Node p = enq(node);
        //获取前继节点的状态
        int ws = p.waitStatus;
        //如果前继节点的状态为1证明被取消
        //如果修改前继节点的状态失败，证明有并发操作
        if (ws > 0 || !p.compareAndSetWaitStatus(ws, Node.SIGNAL))
            //总之失败了，唤醒当前线程，因为前面没有节点可以唤醒当前节点
            LockSupport.unpark(node.thread);
        //如果成功返回true
        return true;
      }