背景:
上一篇文章基于object的wait、notify实现了生产者、消费者模式。本篇文章继续梳理Condition。
condition介绍及demo
Condition是在java1.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()。
下面是demo:
packagethread;
importjava.util.concurrent.locks.Condition;
importjava.util.concurrent.locks.Lock;
importjava.util.concurrent.locks.ReentrantLock;
/**
*
*@authorzhangliang
*
*2016年4月8日下午5:48:54
*/
publicclassConTest{
finalLocklock=newReentrantLock();
finalConditioncondition=lock.newCondition();
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
ConTesttest=newConTest();
Producerproducer=test.newProducer();
Consumerconsumer=test.newConsumer();
consumer.start();
producer.start();
}
classConsumerextendsThread{
@Override
publicvoidrun(){
consume();
}
privatevoidconsume(){
try{
lock.lock();
System.out.println("我在等一个新信号"+this.currentThread().getName());
condition.await();
}catch(InterruptedExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}finally{
System.out.println("拿到一个信号"+this.currentThread().getName());
lock.unlock();
}
}
}
classProducerextendsThread{
@Override
publicvoidrun(){
produce();
}
privatevoidproduce(){
try{
lock.lock();
System.out.println("我拿到锁"+this.currentThread().getName());
condition.signalAll();
System.out.println("我发出了一个信号:"+this.currentThread().getName());
}finally{
lock.unlock();
}
}
}
}运行结果:
Condition的执行方式,是当在线程Consumer中调用await方法后,线程Consumer将释放锁,并且将自己沉睡,等待唤醒,线程Producer获取到锁后,开始做事,完毕后,调用Condition的signalall方法,唤醒线程Consumer,线程Consumer恢复执行。
以上说明Condition是一个多线程间协调通信的工具类,使得某个,或者某些线程一起等待某个条件(Condition),只有当该条件具备(signal或者signalAll方法被带调用)时,这些等待线程才会被唤醒,从而重新争夺锁。
Condition实现生产者、消费者模式:
packagethread;
importjava.util.PriorityQueue;
importjava.util.concurrent.locks.Condition;
importjava.util.concurrent.locks.Lock;
importjava.util.concurrent.locks.ReentrantLock;
publicclassConTest2{
privateintqueueSize=10;
privatePriorityQueue<Integer>queue=newPriorityQueue<Integer>(queueSize);
privateLocklock=newReentrantLock();
privateConditionnotFull=lock.newCondition();
privateConditionnotEmpty=lock.newCondition();
publicstaticvoidmain(String[]args)throwsInterruptedException{
ConTest2test=newConTest2();
Producerproducer=test.newProducer();
Consumerconsumer=test.newConsumer();
producer.start();
consumer.start();
Thread.sleep(0);
producer.interrupt();
consumer.interrupt();
}
classConsumerextendsThread{
@Override
publicvoidrun(){
consume();
}
volatilebooleanflag=true;
privatevoidconsume(){
while(flag){
lock.lock();
try{
while(queue.size()==0){
try{
System.out.println("队列空,等待数据");
notEmpty.await();
}catch(InterruptedExceptione){
flag=false;
}
}
queue.poll();//每次移走队首元素
notFull.signal();
System.out.println("从队列取走一个元素,队列剩余"+queue.size()+"个元素");
}finally{
lock.unlock();
}
}
}
}
classProducerextendsThread{
@Override
publicvoidrun(){
produce();
}
volatilebooleanflag=true;
privatevoidproduce(){
while(flag){
lock.lock();
try{
while(queue.size()==queueSize){
try{
System.out.println("队列满,等待有空余空间");
notFull.await();
}catch(InterruptedExceptione){
flag=false;
}
}
queue.offer(1);//每次插入一个元素
notEmpty.signal();
System.out.println("向队列取中插入一个元素,队列剩余空间:"+(queueSize-queue.size()));
}finally{
lock.unlock();
}
}
}
}
}运行结果如下:
condition实现分析:
Condition接口包含了多种await方式和两个通知方法
ConditionObject实现了Condition接口,是AbstractQueuedSynchronizer的内部类
Reentrantlock的newCondition方法返回与某个lock实例相关的Condition对象
publicabstractclassAbstractQueuedLongSynchronizer
extendsAbstractOwnableSynchronizer
implementsjava.io.Serializable{
<spanstyle="font-size:18px;">结合上面的类图,我们看到condition实现是依赖于aqs,而aqs是个抽象类。里面定义了同步器的基本框架,实现了基本的结构功能。只留有状态条件的维护由具体同步器根据具体场景来定制,如常见的 ReentrantLock 、 RetrantReadWriteLock和CountDownLatch 等等,AQS内容太多,尽量只简明梳理condition相关流程,不太深入理解底层源码。</span>
下面结合上面demo来分析流程。
reentrantLock.newCondition()返回的是Condition的一个实现,该类在AbstractQueuedSynchronizer(AQS)中被实现,叫做newCondition()
publicConditionnewCondition(){
returnsync.newCondition();
}我们看一下这个await的方法,它是AQS的方法,
public final void await() throws InterruptedException
{ |
02 | if (Thread.interrupted()) |
03 | throw new InterruptedException(); |
04 | Node node=addConditionWaiter(); //将当前线程包装下后, |
05 | //添加到Condition自己维护的一个链表中。 |
06 | int savedState =fullyRelease(node); //释放当前线程占有的锁,从demo中看到, |
10 | while (!isOnSyncQueue(node))
{ //释放完毕后,遍历AQS的队列,看当前节点是否在队列中, |
11 | //不在
说明它还没有竞争锁的资格,所以继续将自己沉睡。 |
12 | //直到它被加入到队列中,聪明的你可能猜到了, |
13 | //没有错,在singal的时候加入不就可以了? |
14 | LockSupport.park( this ); |
15 | if ((interruptMode =checkInterruptWhileWaiting(node))!= 0 ) |
18 | //被唤醒后,重新开始正式竞争锁,同样,如果竞争不到还是会将自己沉睡,等待唤醒重新开始竞争。 |
19 | if (acquireQueued(node, savedState)&&interruptMode!=THROW_IE) |
20 | interruptMode =REINTERRUPT; |
21 | if (node.nextWaiter != null ) |
22 | unlinkCancelledWaiters(); |
24 | reportInterruptAfterWait(interruptMode); |
回到上面的demo,锁被释放后,线程Consumer开始沉睡,这个时候线程因为线程Consumer沉睡时,会唤醒AQS队列中的头结点,所所以线程Producer会开始竞争锁,并获取到,执行完后线程Producer会调用signal方法,“发出”signal信号,signal方法如下:
1 | public final void signal()
{ |
2 | if (!isHeldExclusively()) |
3 | throw new IllegalMonitorStateException(); |
4 | Node first=firstWaiter; //firstWaiter为condition自己维护的一个链表的头结点, |
说明下,其实Condition内部维护了等待队列的头结点和尾节点,该队列的作用是存放等待signal信号的线程,该线程被封装为Node节点后存放于此。
而Condition自己也维护了一个队列,该队列的作用是维护一个等待signal信号的队列,两个队列的作用是不同,事实上,每个线程也仅仅会同时存在以上两个队列中的一个,流程是这样的:
注意:
1.线程producer调用signal方法,这个时候Condition的等待队列中只有线程Consumer一个节点,于是它被取出来,并被加入到AQS的等待队列中。注意,这个时候,线程Consumer并没有被唤醒。
2.Sync是AQS的抽象子类,实现可重入和互斥的大部分功能。在Sync的子类中有FairSync和NonfairSync两种代表公平锁策略和非公平锁策略。Synclock方法留给子类去实现,NonfairSync的实现:
finalvoidlock(){
if(compareAndSetState(0,1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}其中如果一开始获取锁成功,是直接设置当前线程。
否则执行acquire(1),也就是进入aqs等待队列。这里不展开细节。
可以这样理解,整个协作过程是靠结点在AQS的等待队列和Condition的等待队列中来回移动实现的,每个队列的意义不同,Condition作为一个条件类,很好的自己维护了一个等待信号的队列,并在适时的时候将结点加入到AQS的等待队列中来实现的唤醒操作
本文先整理到这里吧。
后记:
梳理本文的过程比较痛苦,为什么呢?因为我没有吃透这一块,发现牵扯的很多,脑子很乱,有广度又有深度,感觉没法梳理,决定一点一点去啃,从浅入深的去梳理,从锁,同步,阻塞队列,并发容器开始,到依赖的底层aqs\原子变量,再到更底层的volatile、cas。其中aqs是其中的关键,很多j.u.c的包是围绕它实现的。目标就是会用,熟悉原理,读懂源码,写出demo,关键地方梳理出流程图,加油!
参考:http://www.cnblogs.com/dolphin0520/p/3920385.htmlhttp://ifeve.com/understand-condition/http://ifeve.com/java-special-troops-aqs/