java condition使用及分析

转载 2018年04月17日 20:39:04

condition 介绍及demo

 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()。

下面是demo:  

[java] view plain copy
  1. package thread;  
  2.   
  3. import java.util.concurrent.locks.Condition;  
  4. import java.util.concurrent.locks.Lock;  
  5. import java.util.concurrent.locks.ReentrantLock;  
  6. /** 
  7.  *  
  8.  * @author zhangliang 
  9.  * 
  10.  * 2016年4月8日 下午5:48:54 
  11.  */  
  12. public class ConTest {  
  13.       
  14.      final Lock lock = new ReentrantLock();  
  15.      final Condition condition = lock.newCondition();  
  16.   
  17.     public static void main(String[] args) {  
  18.         // TODO Auto-generated method stub  
  19.         ConTest test = new ConTest();  
  20.         Producer producer = test.new Producer();  
  21.         Consumer consumer = test.new Consumer();  
  22.                 
  23.           
  24.         consumer.start();   
  25.         producer.start();  
  26.     }  
  27.       
  28.      class Consumer extends Thread{  
  29.            
  30.             @Override  
  31.             public void run() {  
  32.                 consume();  
  33.             }  
  34.                 
  35.             private void consume() {  
  36.                                
  37.                     try {  
  38.                            lock.lock();  
  39.                         System.out.println("我在等一个新信号"+this.currentThread().getName());  
  40.                         condition.await();  
  41.                           
  42.                     } catch (InterruptedException e) {  
  43.                         // TODO Auto-generated catch block  
  44.                         e.printStackTrace();  
  45.                     } finally{  
  46.                         System.out.println("拿到一个信号"+this.currentThread().getName());  
  47.                         lock.unlock();  
  48.                     }  
  49.                   
  50.             }  
  51.         }  
  52.        
  53.      class Producer extends Thread{  
  54.            
  55.             @Override  
  56.             public void run() {  
  57.                 produce();  
  58.             }  
  59.                 
  60.             private void produce() {                   
  61.                     try {  
  62.                            lock.lock();  
  63.                            System.out.println("我拿到锁"+this.currentThread().getName());  
  64.                             condition.signalAll();                             
  65.                         System.out.println("我发出了一个信号:"+this.currentThread().getName());  
  66.                     } finally{  
  67.                         lock.unlock();  
  68.                     }  
  69.                 }  
  70.      }  
  71.           
  72. }  
运行结果:


Condition的执行方式,是当在线程Consumer中调用await方法后,线程Consumer将释放锁,并且将自己沉睡,等待唤醒,线程Producer获取到锁后,开始做事,完毕后,调用Condition的signalall方法,唤醒线程Consumer,线程Consumer恢复执行。

以上说明Condition是一个多线程间协调通信的工具类,使得某个,或者某些线程一起等待某个条件(Condition),只有当该条件具备( signal 或者 signalAll方法被带调用)时 ,这些等待线程才会被唤醒,从而重新争夺锁。

Condition实现生产者、消费者模式:

[java] view plain copy
  1. package thread;  
  2.   
  3. import java.util.PriorityQueue;  
  4. import java.util.concurrent.locks.Condition;  
  5. import java.util.concurrent.locks.Lock;  
  6. import java.util.concurrent.locks.ReentrantLock;  
  7.   
  8. public class ConTest2 {  
  9.         private int queueSize = 10;  
  10.         private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);  
  11.         private Lock lock = new ReentrantLock();  
  12.         private Condition notFull = lock.newCondition();  
  13.         private Condition notEmpty = lock.newCondition();  
  14.            
  15.         public static void main(String[] args) throws InterruptedException  {  
  16.             ConTest2 test = new ConTest2();  
  17.             Producer producer = test.new Producer();  
  18.             Consumer consumer = test.new Consumer();                
  19.             producer.start();  
  20.             consumer.start();  
  21.             Thread.sleep(0);  
  22.             producer.interrupt();  
  23.             consumer.interrupt();  
  24.         }  
  25.             
  26.         class Consumer extends Thread{              
  27.             @Override  
  28.             public void run() {  
  29.                 consume();  
  30.             }  
  31.             volatile boolean flag=true;    
  32.             private void consume() {  
  33.                 while(flag){  
  34.                     lock.lock();  
  35.                     try {  
  36.                         while(queue.isEmpty()){  
  37.                             try {  
  38.                                 System.out.println("队列空,等待数据");  
  39.                                 notEmpty.await();  
  40.                             } catch (InterruptedException e) {                              
  41.                                 flag =false;  
  42.                             }  
  43.                         }  
  44.                         queue.poll();                //每次移走队首元素  
  45.                         notFull.signal();  
  46.                         System.out.println("从队列取走一个元素,队列剩余"+queue.size()+"个元素");  
  47.                     } finally{  
  48.                         lock.unlock();  
  49.                     }  
  50.                 }  
  51.             }  
  52.         }  
  53.             
  54.         class Producer extends Thread{              
  55.             @Override  
  56.             public void run() {  
  57.                 produce();  
  58.             }  
  59.             volatile boolean flag=true;    
  60.             private void produce() {  
  61.                 while(flag){  
  62.                     lock.lock();  
  63.                     try {  
  64.                         while(queue.size() == queueSize){  
  65.                             try {  
  66.                                 System.out.println("队列满,等待有空余空间");  
  67.                                 notFull.await();  
  68.                             } catch (InterruptedException e) {  
  69.                                   
  70.                                 flag =false;  
  71.                             }  
  72.                         }  
  73.                         queue.offer(1);        //每次插入一个元素  
  74.                         notEmpty.signal();  
  75.                         System.out.println("向队列取中插入一个元素,队列剩余空间:"+(queueSize-queue.size()));  
  76.                     } finally{  
  77.                         lock.unlock();  
  78.                     }  
  79.                 }  
  80.             }  
  81.         }  
  82.     }  
运行结果如下:


condition实现分析:


  • Condition接口包含了多种await方式和两个通知方法
  • ConditionObject实现了Condition接口,是AbstractQueuedSynchronizer的内部类
  • Reentrantlock的newCondition方法返回与某个lock实例相关的Condition对象
[java] view plain copy
  1. public abstract class AbstractQueuedLongSynchronizer  
  2.     extends AbstractOwnableSynchronizer  
  3.     implements java.io.Serializable {  

[java] view plain copy
  1. <span style="font-size:18px;">结合上面的类图,我们看到condition实现是依赖于aqs,而aqs是个抽象类。里面定义了同步器的基本框架,实现了基本的结构功能。只留有状态条件的维护由具体同步器根据具体场景来定制,如常见的 ReentrantLock 、 RetrantReadWriteLock和CountDownLatch 等等,AQS内容太多,尽量只简明梳理condition相关流程,不太深入理解底层源码。</span>  

下面结合上面demo来分析流程。
reentrantLock.newCondition() 返回的是Condition的一个实现,该类在AbstractQueuedSynchronizer(AQS)中被实现,叫做newCondition()

[java] view plain copy
  1. public Condition newCondition() {  
  2.     return sync.newCondition();  
  3. }  
我们看一下这个await的方法,它是AQS的方法,


public final void await() throws InterruptedException {
02if (Thread.interrupted())
03 throw new InterruptedException();
04 Node node = addConditionWaiter(); //将当前线程包装下后,
05                                   //添加到Condition自己维护的一个链表中。
06int savedState = fullyRelease(node);//释放当前线程占有的锁,从demo中看到,
07                                       //调用await前,当前线程是占有锁的
08 
09int interruptMode = 0;
10 while (!isOnSyncQueue(node)) {//释放完毕后,遍历AQS的队列,看当前节点是否在队列中,
11                           //不在 说明它还没有竞争锁的资格,所以继续将自己沉睡。
12                             //直到它被加入到队列中,聪明的你可能猜到了,
13                            //没有错,在singal的时候加入不就可以了?
14 LockSupport.park(this);
15 if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
16 break;
17 }
18//被唤醒后,重新开始正式竞争锁,同样,如果竞争不到还是会将自己沉睡,等待唤醒重新开始竞争。
19if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
20 interruptMode = REINTERRUPT;
21 if (node.nextWaiter != null)
22 unlinkCancelledWaiters();
23 if (interruptMode != 0)
24 reportInterruptAfterWait(interruptMode);
25 }

回到上面的demo,锁被释放后,线程Consumer开始沉睡,这个时候线程因为线程Consumer沉睡时,会唤醒AQS队列中的头结点,所所以线程Producer会开始竞争锁,并获取到,执行完后线程Producer会调用signal方法,“发出”signal信号,signal方法如下:

1public final void signal() {
2 if (!isHeldExclusively())
3 throw new IllegalMonitorStateException();
4 Node first = firstWaiter; //firstWaiter为condition自己维护的一个链表的头结点,
5                          //取出第一个节点后开始唤醒操作
6 if (first != null)
7 doSignal(first);
8 }
说明下,其实Condition内部维护了等待队列的头结点和尾节点,该队列的作用是存放等待signal信号的线程,该线程被封装为Node节点后存放于此。


而Condition自己也维护了一个队列,该队列的作用是维护一个等待signal信号的队列,两个队列的作用是不同,事实上,每个线程也仅仅会同时存在以上两个队列中的一个,流程是这样的:



注意:

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

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

[java] view plain copy
  1. final void lock() {  
  2.            if (compareAndSetState(01))  
  3.                setExclusiveOwnerThread(Thread.currentThread());  
  4.            else  
  5.                acquire(1);  
  6.        }  
其中如果一开始获取锁成功,是直接设置当前线程。

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

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

本文先整理到这里吧。

后记:

梳理本文的过程比较痛苦,为什么呢?因为我没有吃透这一块,发现牵扯的很多,脑子很乱,有广度又有深度,感觉没法梳理,决定一点一点去啃,从浅入深的去梳理,从锁,同步,阻塞队列,并发容器开始,到依赖的底层aqs\原子变量,再到更底层的volatile、cas。其中aqs是其中的关键,很多j.u.c的包是围绕它实现的。目标就是会用,熟悉原理,读懂源码,写出demo,关键地方梳理出流程图,加油!

参考:

http://www.cnblogs.com/dolphin0520/p/3920385.html

http://ifeve.com/understand-condition/

http://ifeve.com/java-special-troops-aqs/

出处:https://blog.csdn.net/bohu83/article/details/51098106

java Condition源码分析

JUC提供了Lock可以方便的进行锁操作,但是有时候我们也需要对线程进行条件性的阻塞和唤醒,这时我们就需要condition条件变量,它就像是在线程上加了多个开关,可以方便的对持有锁的线程进行阻塞和唤...
  • qilixiang012
  • qilixiang012
  • 2015-04-23 09:21:42
  • 1858

java并发-AQS.ObjectCondition源码解析

1 什么是条件队列        它使得一组线程能够通过某种方式来等待特定的条件变成真,条件队列的元素是一个个正在等待状态的线程。对象的内置锁(synchronized语义对应的同步机制),关联着一个...
  • wojiushiwo945you
  • wojiushiwo945you
  • 2014-12-29 15:43:15
  • 3124

《Java源码分析》:Condition

《Java源码分析》:Condition如下这篇博文讲解的Condition真心将的好,自己结合了源码也基本上对Condition有了一个大致的了解。写篇博客记录下。参考博客地址如下:http://i...
  • u010412719
  • u010412719
  • 2016-08-01 22:01:03
  • 3918

Java多线程开发之~~~多条件Condition接口的使用

我们在多线程开发中,可能会出现这种情况。就是一个线程需要另外一个线程满足某某条件才能继续运行,或者需 要其他线程满足好几个条件才能运行,对于这样的多条件的多线程并发,我们如何控制好各个线程之间的关系,...
  • a352193394
  • a352193394
  • 2014-09-21 19:33:19
  • 3762

【java并发】条件阻塞Condition的应用

Condition将Object监视器方法(wait、notify 和 notifyAll)分解成截然不同的对象,以便通过将这些对象与任意Lock实现组合使用,为每个对象提供多个等待 set(wait...
  • eson_15
  • eson_15
  • 2016-06-04 16:38:45
  • 4757

Condition使用总结

一、介绍 Condition是在java 1.5中才出现的,它用来替代传统的Object的wait()、notify()实现线程间的协作,相比使用Object的wait()、notify(),使用C...
  • HEYUTAO007
  • HEYUTAO007
  • 2015-11-17 17:14:04
  • 3514

使用java Condition构建生产者消费者

1.Condition介绍在上一篇文章中曾经提到对象的wait和notify方法,condition类其实就是这种方法的一种替代性产物。 Condition对象是同Lock结合使用,由Lock进行创...
  • YouMengJiuZhuiBa
  • YouMengJiuZhuiBa
  • 2015-11-18 21:49:19
  • 651

Java并行编程-lock中使用多条件condition(生产者消费者模式实例)

Java 并发包下的提供Lock,Lock相对于Synchronized可以更好的解决线程同步问题,更加的灵活和高效,并且ReadWriteLock锁还能实现读、写的分离。但线程间仅仅互斥是不够的,还...
  • chenchaofuck1
  • chenchaofuck1
  • 2016-06-05 23:37:27
  • 9055
收藏助手
不良信息举报
您举报文章:java condition使用及分析
举报原因:
原因补充:

(最多只允许输入30个字)