ReentrantLock的newCondition方法

一、简单使用

关键字synchronized与wait()/notify()这两个方法一起使用可以实现等待/通知模式， Lock锁的newContition()方法返回Condition对象，Condition类也可以实现等待/通知模式。

用notify()通知时，JVM会随机唤醒某个等待的线程，使用Condition类可以进行选择性通知， Condition比较常用的两个方法：

● await()会使当前线程等待,同时会释放锁,当其他线程调用signal()时,线程会重新获得锁并继续执行。

● signal()用于唤醒一个等待的线程。

注意：在调用Condition的await()/signal()方法前，也需要线程持有相关的Lock锁，调用await()后线程会释放这个锁，在singal()调用后会从当前Condition对象的等待队列中，唤醒一个线程，唤醒的线程尝试获得锁，一旦获得锁成功就继续执行。

/**
 * @author xia17
 * @date 2022/1/7
 */
public class ConditionTest {

    /** 定义锁 */
    static Lock lock = new ReentrantLock();
    /** 获得Condition对象 */
    static Condition condition = lock.newCondition();

    /**
     * 定义线程
     */
    static class SubThread extends Thread{
        @Override
        public void run() {
            //在调用await()前必须先获得锁
            lock.lock();
            try {
                System.out.println("method lock");
                //等待
                condition.await();
                System.out.println("method  await");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 释放锁
                lock.unlock();
                System.out.println("method unlock");
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        SubThread t = new SubThread();
        t.start();
        //子线程启动后,会转入等待状态

        Thread.sleep(3000);
        //主线程在睡眠3秒后,唤醒子线程的等待
        condition.signal();
        lock.lock();
        try {
            Thread.sleep(1000);
            System.out.println("哈哈");
        } finally {
            lock.unlock();
        }
    }

}

/**
 * @author xia17
 * @date 2022/1/7
 */
public class ConditionTest {

    static class Service {
        /** 定义锁对象 */
        private final ReentrantLock lock = new ReentrantLock();
        /** 定义两个Condtion对象 */
        private final Condition conditionA = lock.newCondition();
        private final Condition conditionB = lock.newCondition();

        /**
         * 定义方法,使用conditionA等待
         */
        public void waitMethodA() {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + " begin wait:" + System.currentTimeMillis());
                //等待
                conditionA.await();
                System.out.println(Thread.currentThread().getName() + " end wait:" + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        /**
         * 定义方法,使用conditionB等待
         */
        public void waitMethodB() {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + " begin wait:" + System.currentTimeMillis());
                //等待
                conditionB.await();
                System.out.println(Thread.currentThread().getName() + " end wait:" + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        /**
         * 定义方法唤醒conditionA对象上的等待
         * */
        public void signalA() {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + " sigal A time = " + System.currentTimeMillis());
                conditionA.signal();
                System.out.println(Thread.currentThread().getName() + " sigal A time = " + System.currentTimeMillis());
            } finally {
                lock.unlock();
            }
        }

        /**
         * 定义方法唤醒conditionB对象上的等待
         */
        public void signalB() {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + " sigal A time = " + System.currentTimeMillis());
                conditionB.signal();
                System.out.println(Thread.currentThread().getName() + " sigal A time = " + System.currentTimeMillis());
            } finally {
                lock.unlock();
            }
        }

    }

    public static void main(String[] args) throws InterruptedException {
        Service service = new Service();

        //开启两个线程,分别调用waitMethodA(),waitMethodB()方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                service.waitMethodA();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                service.waitMethodB();
            }
        }).start();

        //main线程睡眠3秒
        Thread.sleep(2000);
        service.signalA();
        Thread.sleep(1000);
        service.signalB();
    }

}

二、Condition接口

condition可以通俗的理解为条件队列。当一个线程在调用了await方法以后，直到线程等待的某个条件为真的时候才会被唤醒。这种方式为线程提供了更加简单的等待/通知模式。Condition必须要配合锁一起使用，因为对共享状态变量的访问发生在多线程环境下。一个Condition的实例必须与一个Lock绑定，因此Condition一般都是作为Lock的内部实现。

await() ：造成当前线程在接到信号或被中断之前一直处于等待状态。

await(long time, TimeUnit unit) ：造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态

awaitNanos(long nanosTimeout) ：造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。返回值表示剩余时间，如果在nanosTimesout之前唤醒，那么返回值 = nanosTimeout - 消耗时间，如果返回值 <= 0 ,则可以认定它已经超时了。

awaitUninterruptibly() ：造成当前线程在接到信号之前一直处于等待状态。【注意：该方法对中断不敏感】。

awaitUntil(Date deadline) ：造成当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态。如果没有到指定时间就被通知，则返回true，否则表示到了指定时间，返回返回false。

signal() ：唤醒一个等待线程。该线程从等待方法返回前必须获得与Condition相关的锁。

signal()All ：唤醒所有等待线程。能够从等待方法返回的线程必须获得与Condition相关的锁。

三、Condition实现的分析

在这里插入图片描述

Condition接口包含了多种await方式和两个通知方法

ConditionObject实现了Condition接口，是AbstractQueuedSynchronizer的内部类（因为Condition的操作都需要获取想关联的锁）

Reentrantlock的newCondition方法返回与某个lock实例相关的Condition对象

我们看到condition实现是依赖于aqs，而aqs是个抽象类。里面定义了同步器的基本框架，实现了基本的结构功能。只留有状态条件的维护由具体同步器根据具体场景来定制，如常见的 ReentrantLock 、 RetrantReadWriteLock和CountDownLatch 等等，

3.1 等待队列(数据结构)

Condition是AQS的内部类。每个Condition对象都包含一个队列(等待队列)。等待队列是一个FIFO(先进先出)的队列，在队列中的每个节点都包含了一个线程引用，该线程就是在Condition对象上等待的线程，如果一个线程调用了Condition.await()方法，那么该线程将会释放锁、构造成节点加入等待队列并进入等待状态。AQS有一个同步队列和多个等待队列，节点都是Node。等待队列的基本结构如下所示。

在这里插入图片描述

等待分为首节点和尾节点。当一个线程调用Condition.await()方法，将会以当前线程构造节点，并将节点从尾部加入等待队列。新增节点就是将尾部节点指向新增的节点。节点引用更新本来就是在获取锁以后的操作，所以不需要CAS保证。同时也是线程安全的操作。

public class ConditionObject implements Condition, java.io.Serializable {
    private static final long serialVersionUID = 1173984872572414699L;
    /** First node of condition queue. */
    private transient Node firstWaiter;
    /** Last node of condition queue. */
    private transient Node lastWaiter;

3.2 等待方法 await()

当线程调用了Condition的await（）方法以后。线程就作为队列中的一个节点被加入到等待队列中去了。同时会释放锁的拥有。当从await方法返回的时候。当前线程一定会获取condition相关联的锁。

如果从队列（同步队列和等待队列）的角度去看await（）方法，当调用await（）方法时，相当于同步队列的首节点（获取锁的节点）移动到Condition的等待队列中。

调用该方法的线程成功的获取锁的线程，也就是同步队列的首节点，该方法会将当前线程构造成节点并加入到等待队列中，然后释放同步状态，唤醒同步队列中的后继节点，然后当前线程会进入等待状态。

当等待队列中的节点被唤醒的时候，则唤醒节点的线程开始尝试获取同步状态。如果不是通过其他线程调用Condition.signal()方法唤醒，而是对等待线程进行中断，则会抛出InterruptedException异常信息。

在这里插入图片描述

我们看一下这个await的方法，它是AQS的方法

public final void await() throws InterruptedException {
	if (Thread.interrupted())
throw new InterruptedException();
Node node = addConditionWaiter(); //将当前线程包装下后，
//添加到Condition自己维护的一个链表中。
int savedState = fullyRelease(node);//释放当前线程占有的锁，从demo中看到，
//调用await前，当前线程是占有锁的

int interruptMode = 0;
	 while (!isOnSyncQueue(node)) {//释放完毕后，遍历AQS的队列，看当前节点是否在队列中，
//不在 说明它还没有竞争锁的资格，所以继续将自己沉睡。
//直到它被加入到队列中，聪明的你可能猜到了，
//没有错，在singal的时候加入不就可以了？
LockSupport.park(this);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
//被唤醒后，重新开始正式竞争锁，同样，如果竞争不到还是会将自己沉睡，等待唤醒重新开始竞争。
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
if (node.nextWaiter != null)
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
}

结合代码去看，同步队列的首节点并不会直接加入等待队列，而是通过addConditionWaiter把当前线程构造成一个新节点并加入到等待队列中。

/**
         * Adds a new waiter to wait queue.
         * @return its new wait node
         */
        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;
        }

3.3 通知方法 signal()

调用Condition的signal()方法，将会唤醒在等待队列中等待最长时间的节点（条件队列里的首节点），在唤醒节点前，会将节点移到同步队列中。当前线程加入到等待队列中如图所示：

在这里插入图片描述

锁调用await被释放后，该线程开始沉睡，这个时候线程因为该线程沉睡时，会唤醒AQS队列中的头结点，所以另一个线程会开始竞争锁，并获取到，执行完后另一个线程会调用signal方法，“发出”signal信号，signal方法如下：

public final void signal() {
	 if (!isHeldExclusively())
	 throw new IllegalMonitorStateException();
	 Node first = firstWaiter; //firstWaiter为condition自己维护的一个链表的头结点，
	                          //取出第一个节点后开始唤醒操作
	 if (first != null)
	 doSignal(first);
	 }

在调用signal()方法之前必须先判断是否获取到了锁（isHeldExclusively方法）。接着获取等待队列的首节点，将其移动到同步队列并且利用LockSupport唤醒节点中的线程。
被唤醒的线程将从await方法中的while循环中退出（ while (!isOnSyncQueue(node)) { 方法返回true，节点已经在同步队列中）。随后调用同步器的acquireQueued（）方法加入到同步状态的竞争当中去。成功获取到竞争的线程从先前调用await方法返回，此时该线程已经成功获取了锁。

AQS的同步队列与Condition的等待队列，两个队列的作用是不同，事实上，每个线程也仅仅会同时存在以上两个队列中的一个，流程是这样的：

在这里插入图片描述

注意：

1.main调用signal方法，这个时候Condition的等待队列中只有线程t一个节点，于是它被取出来，并被加入到AQS的等待队列中。注意，这个时候，线程t并没有被唤醒。

2.Sync是AQS的抽象子类，实现可重入和互斥的大部分功能。在Sync的子类中有FairSync和NonfairSync两种代表公平锁策略和非公平锁策略。Sync lock方法留给子类去实现，NonfairSync的实现：

final void lock() {
           if (compareAndSetState(0, 1))
               setExclusiveOwnerThread(Thread.currentThread());
           else
               acquire(1);
       }

其中如果一开始获取锁成功，是直接设置当前线程。

否则执行acquire(1),也就是进入aqs等待队列。这里不展开细节。

可以这样理解，整个协作过程是靠结点在AQS的等待队列和Condition的等待队列中来回移动实现的，每个队列的意义不同，Condition作为一个条件类，很好的自己维护了一个等待信号的队列，并在适时的时候将结点加入到AQS的等待队列中来实现的唤醒操作

文章摘抄自： https://blog.csdn.net/a1439775520/article/details/98471610

时间： 2022-01-07