Java源码分析系列笔记-7.Lock之Condition

目录

• 1. 是什么
• 2. 如何使用
• 3. 实现原理
  • 3.1. uml
  • 3.2. 创建Condition对象
    • 3.2.1. 创建AQS.ConditionObject对象
      • 3.2.1.1. ConditionObject内部也有一个双向队列
  • 3.3. await方法【阻塞等待】
    • 3.3.1. 加入condition队列尾部
    • 3.3.2. 调用AQS解锁，释放互斥量
      • 3.3.2.1. 尝试释放互斥量
    • 3.3.3. 检测是否在AQS队列，不在则需要阻塞
    • 3.3.4. 当前节点已经在AQS队列中了，获取锁
      • 3.3.4.1. 判断是否需要阻塞
        • 3.3.4.1.1. 阻塞当前线程
  • 3.4. signalAll方法【唤醒所有阻塞等待的节点】
    • 3.4.1. 把condition队列的所有节点转移到AQS队列中
      • 3.4.1.1. 每转移一个condition队列中的节点到aqs队列中，就唤醒一个
        • 3.4.1.1.1. 如何转移的
  • 3.5. signal方法【只唤醒头部阻塞等待的节点】
    • 3.5.1. 唤醒头节点
• 4. 为什么await需要先释放锁，而signal不需要
• 5. 总结
• 6. 参考链接

1. 是什么

类似object的wait和notify方法配合synchronized使用

condition的await和notify方法配合Lock使用，用来实现条件等待与唤醒

2. 如何使用

• 生产者消费者模式

public class ConditionTest
{
    private Lock lock;//一个锁说明读写互斥
    private int capacity;
    private List<Object> items;
    private Condition notFull;//用来唤醒写线程
    private Condition notEmpty;//用来唤醒读线程

    public ConditionTest(int capacity)
    {
        this.capacity = capacity;
        this.items = new ArrayList<>();
        this.lock = new ReentrantLock();
        this.notFull = lock.newCondition();
        this.notEmpty = lock.newCondition();
    }

    public void add(Object data) throws InterruptedException
    {
        try
        {
            lock.lock();
            //新增的时候如果已经满了，那么等待 非满信号 唤醒
            while (this.items.size() == capacity)
            {
                this.notFull.await();
            }

            //增加了一个元素，那么 唤醒非空
            this.items.add(data);
            this.notEmpty.signalAll();

        }
        finally
        {
            lock.unlock();
        }
    }

    public Object remove() throws InterruptedException
    {
        try
        {
            lock.lock();

            //删除的时候已经空了，那么等待 非空信号 唤醒
            while (this.items.size() == 0)
            {
                this.notEmpty.await();
            }

            //删除了一个元素，那么 唤醒非满
            Object data = this.items.remove(0);
            this.notFull.signalAll();
            return data;
        }
        finally
        {
            lock.unlock();
        }
    }

    public static void main(String[] args)
    {
        ConditionTest conditionTest = new ConditionTest(5);
        new Thread(() -> {
            for (int i = 0; i < 1000; i++)
            {
                try
                {
                    conditionTest.add(i);
                    System.out.println(String.format("生产者放入%d", i));
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
        }).start();

        new Thread(() -> {
            try
            {
                while (true)
                {
                    Object data = conditionTest.remove();
                    System.out.println(String.format("消费者消费%d", data));
                }
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }).start();

    }
}

3. 实现原理

3.1. uml

3.2. 创建Condition对象

• newCondition方法

public Condition newCondition() {
	//调用Sync的newCondition方法
    return sync.newCondition();
}

3.2.1. 创建AQS.ConditionObject对象

• Sync newConditoin方法

final ConditionObject newCondition() {
	//AQS的ConditionObject
    return new ConditionObject();
}

3.2.1.1. ConditionObject内部也有一个双向队列

public class ConditionObject implements Condition, java.io.Serializable {
	//condition队列也是一个双向队列
    private transient Node firstWaiter;
    private transient Node lastWaiter;

    public ConditionObject() { }
}

结构如下图：



没错，Condition队列和AQS就是两个不同队列，Condition的操作就是在这两个队列中来回移动

3.3. await方法【阻塞等待】

public final void await() throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    //加入condition队列尾部
    Node node = addConditionWaiter();
    //调用AQS解锁，释放互斥量（执行await肯定是在获取了锁后的）
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    //调用AQS死循环检测是否在AQS队列中，不在的话阻塞当前线程。
    //什么时候加入AQS队列呢？signal的时候
    while (!isOnSyncQueue(node)) {
        LockSupport.park(this);
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    //获已经在AQS队列中了，获取锁
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    //如果node不是condition队列的尾节点
    if (node.nextWaiter != null) // clean up if cancelled
        //那么遍历删除conditoin队列中所有cancel节点
        unlinkCancelledWaiters();
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}

• 5行：加入condition队列尾部
• 7行：调用AQS解锁，释放互斥量（由此可知执行await肯定是在获取了锁后的）
• 11-15行：不停地检查是否在AQS阻塞队列中，不在的话阻塞当前线程。等待唤醒继续检查
• 17-22行：到达这里的时候说明已经在AQS队列中了，并且已被唤醒，那么我就要去抢占锁了。如果抢占失败继续回到11-15行

下面对这几个步骤作详细说明

3.3.1. 加入condition队列尾部

• addConditionWaiter

private Node addConditionWaiter() {
	//队尾
    Node t = lastWaiter;
    //队尾的状态不为CONDITION（即为CANCEL）
    if (t != null && t.waitStatus != Node.CONDITION) {
    	//删除conditoin队列中所有cancel节点
        unlinkCancelledWaiters();
        //重新从尾节点开始
        t = lastWaiter;
    }
    //构造节点（当前线程，CONDITION状态）
    Node node = new Node(Thread.currentThread(), Node.CONDITION);
    //把节点加入condition队列尾部
    //这是队列为空的情况
    if (t == null)
        firstWaiter = node;
    //队列不为空的情况
    else
        t.nextWaiter = node;
    lastWaiter = node;//新的尾节点
    return node;
}

上面的代码所作的就是用当前线程构造成Condition节点，加入Condition队列的尾部；

除此之外，unlinkCancelledWaiters还会从头部开始往后删除conditoin队列中所有cancel节点，如下：

• unlinkCancelledWaiters方法

private void unlinkCancelledWaiters() {
	//从头节点出发
    Node t = firstWaiter;
    Node trail = null;
    //遍历condition队列
    while (t != null) {
        Node next = t.nextWaiter;
        //如果节点状态为CANCEL
        if (t.waitStatus != Node.CONDITION) {
            //那么从condition队列中删除
            t.nextWaiter = null;
            //头节点是CANCEL的，那就修改头节点
            if (trail == null)
                firstWaiter = next;
            //头节点不是CANCEL的，那就修改前一个节点的nextWaiter
            else
                trail.nextWaiter = next;
            if (next == null)
                lastWaiter = trail;
        }
        //节点状态不为CANCEL，那么跳过
        else
            trail = t;
        //继续下一个节点
        t = next;
    }
}

3.3.2. 调用AQS解锁，释放互斥量

• AQS fullyRelease方法

final int fullyRelease(Node node) {
    boolean failed = true;
    try {
    	//获取当前互斥量
        int savedState = getState();
        //调用AQS.release释放这些互斥量
        if (release(savedState)) {
            //释放成功后返回释放的互斥量个数
            failed = false;
            return savedState;
        } else {
            throw new IllegalMonitorStateException();
        }
    } finally {
    	//解锁失败需要把当前节点置为CANCEL状态
        if (failed)
            node.waitStatus = Node.CANCELLED;
    }
}

• AQS release

public final boolean release(int arg) {
    //调用AQS.tryRelease释放锁
    if (tryRelease(arg)) {
    	//释放锁成功后把AQS队列的头节点的线程唤醒
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

由于ReentrantLock重写的了AQS的tryRelease，因此调用的是ReentrantLock.tryRelease，如下：

3.3.2.1. 尝试释放互斥量

• ReentrantLock.tryRelease

protected final boolean tryRelease(int releases) {
	//计算释放完releases个信号量还剩多少要释放
    int c = getState() - releases;
	//解锁的必须和加锁同一线程
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {//剩余0个说明解锁成功
        free = true;
        setExclusiveOwnerThread(null);//置持有锁的线程为空
    }
	//设置剩余的信号量
	//由于解锁的只有一个线程，所以这里不需要使用CAS操作设置state
    setState(c);
    return free;
}

3.3.3. 检测是否在AQS队列，不在则需要阻塞

• isOnSyncQueue方法

final boolean isOnSyncQueue(Node node) {
		//node的状态是CONDITION，说明还在condition队列中 或者 前一个节点为空
        if (node.waitStatus == Node.CONDITION || node.prev == null)
            return false;//返回false，表示不在AQS队列中
        //next不为空（next是AQS队列专用，nextWaiter是Condition队列专用），一定在AQS队列中
        if (node.next != null) // If has successor, it must be on queue
            return true;//返回true，表示在AQS队列中

         //以上两种情况都不符合，那么只能到AQS队列中查找
        return findNodeFromTail(node);
    }

private boolean findNodeFromTail(Node node) {
    Node t = tail;
    //从尾开始遍历，找到node
    for (;;) {
        if (t == node)
            return true;
        if (t == null)
            return false;
        t = t.prev;
    }
}

3.3.4. 当前节点已经在AQS队列中了，获取锁

• acquireQueue

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
    	//死循环直到获取锁成功
        for (;;) {
        	//逻辑1.
    		//当前节点的前一个节点时头节点的时候（公平锁：即我的前面没有人等待获取锁），尝试获取锁
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
            	//获取锁成功后设置头节点为当前节点
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
        	//逻辑2.
            //当前节点的前一个节点状态时SIGNAL（承诺唤醒当前节点）的时候，阻塞当前线程。
            //什么时候唤醒？释放锁的时候
            //唤醒之后干什么？继续死循环执行上面的逻辑1
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }

    } finally {
    	//如果发生了异常，那么执行下面的cancelAcquire方法
        if (failed)
            cancelAcquire(node);
    }
}

3.3.4.1. 判断是否需要阻塞

• shouldParkAfterFailedAcquire

//根据（前一个节点，当前节点）->是否阻塞当前线程
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    //前一个节点的状态时SIGNAL，即释放锁后承诺唤醒当前节点，那么返回true可以阻塞当前线程
    if (ws == Node.SIGNAL)
        return true;
    //前一个节点状态>0，即CANCEL。
    //那么往前遍历找到没有取消的前置节点。同时从链表中移除CANCEL状态的节点
    if (ws > 0) {
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    // 前置节点状态>=0，即0或者propagate。
    //这里通过CAS把前置节点状态改成signal成功获取锁，失败的话再阻塞。why？
    } else {
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

3.3.4.1.1. 阻塞当前线程

• parkAndCheckInterrupt

private final boolean parkAndCheckInterrupt() {
    //使用Unsafe阻塞当前线程，这里会清除线程中断的标记，因此需要返回中断的标记
    LockSupport.park(this);
    return Thread.interrupted();
}

3.4. signalAll方法【唤醒所有阻塞等待的节点】

• ConditionObject signalAll

public final void signalAll() {
	//如果当前线程不是持有互斥量的线程，直接抛出异常
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    //Condition队列不为空
    Node first = firstWaiter;
    if (first != null)
    	//把condition队列的所有节点转移到AQS队列中并唤醒所有线程
        doSignalAll(first);
}

3.4.1. 把condition队列的所有节点转移到AQS队列中

• doSignalAll方法

 private void doSignalAll(Node first) {
 	//清空condition队列的头、尾节点
    lastWaiter = firstWaiter = null;
    //遍历condition队列
    do {
        Node next = first.nextWaiter;
        first.nextWaiter = null;
    	//转移到AQS队列中
        transferForSignal(first);
        first = next;
    } while (first != null);
}

3.4.1.1. 每转移一个condition队列中的节点到aqs队列中，就唤醒一个

• tansferForSignal方法

final boolean transferForSignal(Node node) {
     //当前节点是CONDITION状态，CAS设置为0,如果成功继续15行
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
        return false;//CAS设置失败，那么返回false表示唤醒失败

   //调用AQS enq，把当前节点加入AQS队列
    Node p = enq(node);
    int ws = p.waitStatus;
    //如果该结点的状态为cancel 或者 修改waitStatus为SIGNAL失败
    //没搞懂这个条件什么意思
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        //唤醒当前节点的线程
        LockSupport.unpark(node.thread);
    return true;
}

3.4.1.1.1. 如何转移的

• AQS.enq

private Node enq(final Node node) {
	//死循环直到加入队尾成功
	for (;;) {
		Node t = tail;
		//队列为空初始化头节点（占位符）
		if (t == null) {
		    if (compareAndSetHead(new Node()))
		        tail = head;
		} else {//加入队尾
		    node.prev = t;
		    if (compareAndSetTail(t, node)) {
		        t.next = node;
		        return t;
		    }
		}
	}
}

3.5. signal方法【只唤醒头部阻塞等待的节点】

• ConditionObject signal

public final void signal() {
	//调用ReentrantLock的方法判断当前线程是否持有锁的线程
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    //condition队列不为空
    Node first = firstWaiter;
    if (first != null)
        doSignal(first);
}

3.5.1. 唤醒头节点

• doSignal

private void doSignal(Node first) {
    do {
        if ( (firstWaiter = first.nextWaiter) == null)//修改头结点，完成旧头结点的移出工作
            lastWaiter = null;
        first.nextWaiter = null;
    //将老的头结点，加入到AQS的等待队列中
    //一旦成功唤醒一个，那么退出循环返回（signalAll是唤醒所有）
    } while (!transferForSignal(first) &&
             (first = firstWaiter) != null);
}

4. 为什么await需要先释放锁，而signal不需要

因为await可能需要阻塞，所以在阻塞前需要先释放锁。

5. 总结

condition的一系列操作其实只涉及了AQS队列和condition队列的来回移动

• 当执行await方法时，会把当前线程加入到condition队列中，然后释放锁。接着不断检查是否在AQS队列中。
  
  是的话开始竞争锁，只有AQS队列中的首节点能抢占成功。否则挂起
• 当执行signalAll方法时，会把condition队列中所有节点转移到AQS队列中，并唤醒所有线程。被唤醒的节点会退出是否在AQS队列中的检查，开始抢占锁
• 当执行signal方法时，会把condition队列中头节点转移到AQS队列中，并唤醒该头节点的线程。被唤醒的节点会退出是否在AQS队列中的检查，开始抢占锁

6. 参考链接

• [Java 锁]Condition 详解 - 简书
• 并发编程之 Condition 源码分析 - 掘金