一、Condition介绍
Condition是在java 1.5中才出现的,它用来替代传统的Object的wait()、notify()实现线程间的协作,相比使用Object的wait()、notify(),使用Condition的await()、signal()这种方式实现线程间协作更加安全和高效。因此通常来说比较推荐使用Condition,阻塞队列实际上是使用了Condition来模拟线程间协作。
Condition是个接口,基本的方法就是await()和signal()方法;
Condition依赖于Lock接口,生成一个Condition的基本代码是lock.newCondition()
调用Condition的await()和signal()方法,都必须在lock保护之内,就是说必须在lock.lock()和lock.unlock之间才可以使用。
- Conditon中的await()对应Object的wait();
- Condition中的signal()对应Object的notify();
- Condition中的signalAll()对应Object的notifyAll()。
Condition与Object Monitor Methods的区别:
二、通过demo初步了解Condition
创建生产者、消费者,两者内部共用同一套Queue、Producer、Consumer:
public class App
{
public static void main( String[] args )
{
Queue<String> queue=new LinkedList<>();
Lock lock=new ReentrantLock(); //重入锁
Condition condition=lock.newCondition();
int maxSize=5;
Producer producer=new Producer(queue,maxSize,lock,condition);
Consumer consumer=new Consumer(queue,maxSize,lock,condition);
Thread t1=new Thread(producer);
Thread t2=new Thread(consumer);
t1.start();
t2.start();
}
}
生产者:
public class Producer implements Runnable{
private Queue<String> msg;
private int maxSize;
Lock lock;
Condition condition;
public Producer(Queue<String> msg, int maxSize, Lock lock, Condition condition) {
this.msg = msg;
this.maxSize = maxSize;
this.lock = lock;
this.condition = condition;
}
@Override
public void run() {
int i=0;
while(true){
i++;
lock.lock();
while(msg.size()==maxSize){
System.out.println("生产者队列满了,先等待");
try {
condition.await(); //阻塞线程并释放锁
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("生产消息:"+i);
msg.add("生产者的消息内容"+i);
condition.signal(); //唤醒阻塞状态下的线程
lock.unlock();
}
}
}
消费者:
public class Consumer implements Runnable{
private Queue<String> msg;
private int maxSize;
Lock lock;
Condition condition;
public Consumer(Queue<String> msg, int maxSize, Lock lock, Condition condition) {
this.msg = msg;
this.maxSize = maxSize;
this.lock = lock;
this.condition = condition;
}
@Override
public void run() {
int i=0;
while(true){
i++;
lock.lock(); //synchronized
while(msg.isEmpty()){
System.out.println("消费者队列空了,先等待");
try {
condition.await(); //阻塞线程并释放锁 wait
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("消费消息:"+msg.remove());
condition.signal(); //唤醒阻塞状态下的线程
lock.unlock();
}
}
}
运行测试类App.class,运行结果:
Condition的执行方式,是当在线程Consumer中调用await方法后,线程Consumer将释放锁,并且将自己沉睡,等待唤醒,线程Producer获取到锁后,开始做事,完毕后,调用Condition的signalall方法,唤醒线程Consumer,线程Consumer恢复执行。
以上说明Condition是一个多线程间协调通信的工具类,使得某个,或者某些线程一起等待某个条件(Condition),只有当该条件具备( signal 或者 signalAll方法被带调用)时 ,这些等待线程才会被唤醒,从而重新争夺锁。
三、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接口包含了多种await方式和两个通知方法
ConditionObject实现了Condition接口,是AbstractQueuedSynchronizer的内部类(因为Condition的操作都需要获取想关联的锁)
Reentrantlock的newCondition方法返回与某个lock实例相关的Condition对象。
结合上面的类图,我们看到condition实现是依赖于aqs,而aqs是个抽象类。里面定义了同步器的基本框架,实现了基本的结构功能。只留有状态条件的维护由具体同步器根据具体场景来定制,如常见的 ReentrantLock 、 RetrantReadWriteLock和CountDownLatch 等等
4.1 等待队列
Condition是AQS的内部类。每个Condition对象都包含一个队列(等待队列)。等待队列是一个FIFO的队列,在队列中的每个节点都包含了一个线程引用,该线程就是在Condition对象上等待的线程,如果一个线程调用了Condition.await()方法,那么该线程将会释放锁、构造成节点加入等待队列并进入等待状态。AQS有一个同步队列和多个等待队列,节点都是Node。等待队列的基本结构如下所示:
等待分为首节点和尾节点。当一个线程调用Condition.await()方法,将会以当前线程构造节点,并将节点从尾部加入等待队列。新增节点就是将尾部节点指向新增的节点。节点引用更新本来就是在获取锁以后的操作,所以不需要CAS保证。同时也是线程安全的操作。
4.2 等待
当线程调用了Condition的await()方法以后,线程就作为队列中的一个节点被加入到等待队列中去了。同时会释放锁的拥有。当从await方法返回的时候。当前线程一定会获取condition相关联的锁。
如果从队列(同步队列和等待队列)的角度去看await()方法,当调用await()方法时,相当于同步队列的首节点(获取锁的节点)移动到Condition的等待队列中。
当等待队列中的节点被唤醒的时候,则唤醒节点的线程开始尝试获取同步状态。如果不是通过 其他线程调用Condition.signal()方法唤醒,而是对等待线程进行中断,则会抛出InterruptedException异常信息。
我们看一下这个await的方法,它是AQS的方法:
public final void await() throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
//将当前线程包装下后,
//添加到Condition自己维护的一个链表中。
Node node = addConditionWaiter();
//释放当前线程占有的锁,从demo中看到,
//调用await前,当前线程是占有锁的
int savedState = fullyRelease(node);
int interruptMode = 0;
//释放完毕后,遍历AQS的队列,看当前节点是否在队列中,
//不在 说明它还没有竞争锁的资格,所以继续将自己沉睡。
//直到它被加入到队列中,聪明的你可能猜到了,
//没有错,在singal的时候加入不就可以了?
while (!isOnSyncQueue(node)) {
LockSupport.park(this);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
//被唤醒后,重新开始正式竞争锁,同样,如果竞争不到还是会将自己沉睡,等待唤醒重新开始竞争。
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
if (node.nextWaiter != null) // clean up if cancelled
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
}
结合代码去看,同步队列的首节点 并不会直接加入等待队列,而是通过addConditionWaiter把当前线程构造成一个新节点并加入到等待队列中:
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;
}
4.3 通知
调用Condition的signal()方法,将会唤醒在等待队列中等待最长时间的节点(条件队列里的首节点),在唤醒节点前,会将节点移到同步队列中。当前线程加入到等待队列中如图所示:
回到上面的demo,锁被释放后,线程Producer开始沉睡,这个时候线程因为线程Producer沉睡时,会唤醒AQS队列中的头结点,所以线程Consumer会开始竞争锁,并获取到,执行完后线程Consumer会调用signal方法,“发出”signal信号,signal方法如下:
public final void signal() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
//firstWaiter为condition自己维护的一个链表的头结点,
//取出第一个节点后开始唤醒操作
Node first = firstWaiter;
if (first != null)
doSignal(first);
}
疑问:
为什么②中需要判断前一个节点状态,和cas替换前一个节点状态为signal,明明就存在前一个节点状态不存在,实时新建节点的状况,这种情况下返回前一个节点还有意义吗?
在调用signal()方法之前必须先判断是否获取到了锁(isHeldExclusively方法)。接着获取等待队列的首节点,将其移动到同步队列并且利用LockSupport唤醒节点中的线程。
被唤醒的线程将从await方法中的while循环中退出( while (!isOnSyncQueue(node)) { 方法返回true,节点已经在同步队列中)。随后调用同步器的acquireQueued()方法加入到同步状态的竞争当中去。成功获取到竞争的线程从先前调用await方法返回,此时该线程已经成功获取了锁。
AQS的同步队列与Condition的等待队列,两个队列的作用是不同,事实上,每个线程也仅仅会同时存在以上两个队列中的一个,流程是这样的:
注意:
1.线程Consumer调用signal方法,这个时候Condition的等待队列中只有线程producer一个节点,于是它被取出来,并被加入到AQS的等待队列中。 注意,这个时候,线程producer并没有被唤醒。
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的等待队列中来实现的唤醒操作
五、全流程图分析
5.1 微观
1.先来看一下AQS队列和Condition队列的结构:
2.当线程A运行到await()方法的这个步骤,AQS队列和Condition队列是什么样子呢?
AQS队列和Condition队列结构:
红框部分表示线程A释放了锁,此时线程A就进入了阻塞状态,并且插入了等待队列(Condition队列),线程B抢到了锁,我们知道重入锁,抢占锁是在AQS中进行的,线程B在AQS队列中属于占有锁的状态。
3.当线程B走到了await()方法时,同样也是走到了红框部分(图2):
线程A自旋抢占锁:
分析上面代码:
首先看线程A是否在同步队列:
- 如果不在同步队列,挂起线程(Thread B线程会在在调用singal()处理)
- 如果在同步队列,去抢占锁,然后继续执行
详细说说如果线程A不在同步队列,Thread B线程会在在调用singal()的处理。执行过程如下:
signal()——>doSignal()——>transferForSignal()
我们继续看transferForSignal()方法,会看到红框中代码,这段代码在AQS讲解中分析过,是把node放到同步队列中:
AQS队列和Condition队列结构会由图2->图3(省略了如果线程A不在同步队列的情况)
首先是线程B会加到等待队列中,线程A会抢占锁继续执行。
好了微观部分就分析到这里了。
5.2 宏观
宏观部分就不分析了,因为理解了微观部分,宏观自然就理解了。下图,黑箭头表示Producer线程,红箭头表示Consumer线程,直接贴图: