【Java 并发】【九】【AQS】【四】ReentrantLock的Condition机制原理

public class ReentrantLockConditionTest {
    // 共享变量
    private static int num = 1;
    // 互斥锁 这个例子如果去掉static会发生什么呢？ 这把锁就不是同一把了，就会失效导致结果不对
    private static ReentrantLock lock = new ReentrantLock();
    // reentrantLock创建一个Condition
    private static Condition condition = lock.newCondition();

    static class OddNumberThread extends Thread {
        @Override
        public void run() {
            for (int i=0; i<10000; i++) {
                try {
                    // 由于变量value是非线程安全的，每次操作前需加锁
                    lock.lock();
                    // 当value的值不是奇数的时候，直接沉睡等待
                    while (num % 2 == 0) {
                        // 调用condition的await方法，释放锁，同时进入沉睡
                        // 等待别人调用singal/singalAll唤醒自己，然后重新获取锁
                        condition.await();
                    }
                    // 走到这里说明value是奇数，并且自己获取了锁
                    System.out.print("1");
                    // 执行value的++操作
                    num++;
                    // 唤醒调用condition.await而陷入等待的线程；这里就是唤醒线程2
                    condition.signal();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    // 最后释放锁
                    lock.unlock();
                }
            }
        }
    }
    static class EvenNumberThread extends Thread {
        @Override
        public void run() {
            for (int i=0; i<10000; i++) {
                try {
                    // 获取锁
                    lock.lock();
                    // 当value的值不是偶数的时候，直接沉睡等待
                    while (num % 2 == 1) {
                        // 调用condition的await方法，释放锁，同时进入沉睡
                        // 等待别人调用singal/singalAll唤醒自己，然后重新获取锁
                        condition.await();
                    }
                    // 走到这里说明value是偶数，并且自己获取了锁
                    System.out.print("2");
                    // 执行value的++操作
                    num++;
                    // 唤醒调用condition.await而陷入等待的线程；这里就是唤醒线程2
                    condition.signal();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    // 最后释放锁
                    lock.unlock();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        // 创建两个线程并启动
        OddNumberThread demo1 = new OddNumberThread();
        EvenNumberThread demo2 = new EvenNumberThread();
        demo1.start();
        demo2.start();
        // 等待两个线程都执行完
        demo1.join();
        demo2.join();
    }
}

public final void await() throws InterruptedException {
    // 如果线程被中断了，直接抛出中断异常
    if (Thread.interrupted())
        throw new InterruptedException();
    // 当前线程封装成Node节点，加入condition队列里面
    // 注意：这里是Condition队列，而不是AQS获取锁的等待队列，注意
    Node node = addConditionWaiter();
    // 这里是释放锁，完全释放锁资源，将state归于0
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    // 如果Node节点不在AQS获取锁的等待队列，这里一般都不会在
    while (!isOnSyncQueue(node)) {
        // 直接将线程挂起，让线程沉睡
        LockSupport.park(this);
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    // 走到这里说明有别的线程调用Condition.singal方法将你唤醒了
    // 这里调用AQS的acquireQueue方法，这个方法的作用之前讲过了
    // 就是将你放入AQS的等待队列里面，重新等待获取锁
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    if (node.nextWaiter != null) // clean up if cancelled
        // 这里就是删除一下无效的condition队列节点
        unlinkCancelledWaiters();
    if (interruptMode != 0)
        // 由于等待时间可能太久了，被中断了
        reportInterruptAfterWait(interruptMode);
}

static final class Node {
    static final Node SHARED = new Node();
    static final Node EXCLUSIVE = null;
    static final int CANCELLED = 1;
    static final int SIGNAL = -1;
    // -2表示节点在Condition队列，等待别人唤醒
    static final int CONDITION = -2;
    static final int PROPAGATE = -3;
    // Node节点的等待状态
    volatile int waitStatus;
    // AQS队列中，Node节点指向前一个节点的指针
    volatile Node prev;
    // AQS队列中，Node节点指向后一个节点的指针
    volatile Node next;
    // 线程
    volatile Thread thread;
    // 这里啊就是Condition队列的Node节点，指向下一个节点的指针了
    Node nextWaiter;
}

public class ConditionObject implements Condition, java.io.Serializable {
    // 这里就是指向Condition队列头节点的指针
    private transient Node firstWaiter;
    // 这里就是指向Condition队列尾节点的指针
    private transient Node lastWaiter;
}