关闭

java condition使用及分析

标签: java线程并发
3650人阅读 评论(0) 收藏 举报
分类:

背景:

    上一篇文章基于object的wait、notify实现了生产者、消费者模式。本篇文章继续梳理Condition。

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:  

package thread;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 
 * @author zhangliang
 *
 * 2016年4月8日 下午5:48:54
 */
public class ConTest {
	
	 final Lock lock = new ReentrantLock();
	 final Condition condition = lock.newCondition();

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ConTest test = new ConTest();
	    Producer producer = test.new Producer();
	    Consumer consumer = test.new Consumer();
	          
	    
	    consumer.start(); 
	    producer.start();
	}
	
	 class Consumer extends Thread{
         
	        @Override
	        public void run() {
	            consume();
	        }
	          
	        private void consume() {
	           	             
	                try {
	                	   lock.lock();
	                    System.out.println("我在等一个新信号"+this.currentThread().getName());
	                    condition.await();
	                    
	                } catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} finally{
						System.out.println("拿到一个信号"+this.currentThread().getName());
	                    lock.unlock();
	                }
	            
	        }
	    }
	 
	 class Producer extends Thread{
         
	        @Override
	        public void run() {
	            produce();
	        }
	          
	        private void produce() {	             
	                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实现生产者、消费者模式:

package thread;

import java.util.PriorityQueue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConTest2 {
	    private int queueSize = 10;
	    private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);
	    private Lock lock = new ReentrantLock();
	    private Condition notFull = lock.newCondition();
	    private Condition notEmpty = lock.newCondition();
	     
	    public static void main(String[] args) throws InterruptedException  {
	    	ConTest2 test = new ConTest2();
	        Producer producer = test.new Producer();
	        Consumer consumer = test.new Consumer();	          
	        producer.start();
	        consumer.start();
	        Thread.sleep(0);
	        producer.interrupt();
	        consumer.interrupt();
	    }
	      
	    class Consumer extends Thread{	          
	        @Override
	        public void run() {
	            consume();
	        }
	        volatile boolean flag=true;  
	        private void consume() {
	            while(flag){
	                lock.lock();
	                try {
	                    while(queue.size() == 0){
	                        try {
	                            System.out.println("队列空,等待数据");
	                            notEmpty.await();
	                        } catch (InterruptedException e) {	                          
	                            flag =false;
	                        }
	                    }
	                    queue.poll();                //每次移走队首元素
	                    notFull.signal();
	                    System.out.println("从队列取走一个元素,队列剩余"+queue.size()+"个元素");
	                } finally{
	                    lock.unlock();
	                }
	            }
	        }
	    }
	      
	    class Producer extends Thread{	          
	        @Override
	        public void run() {
	            produce();
	        }
	        volatile boolean flag=true;  
	        private void produce() {
	            while(flag){
	                lock.lock();
	                try {
	                    while(queue.size() == queueSize){
	                        try {
	                            System.out.println("队列满,等待有空余空间");
	                            notFull.await();
	                        } catch (InterruptedException e) {
	                            
	                            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对象
public abstract class AbstractQueuedLongSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {


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

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

    public Condition newCondition() {
        return sync.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中看到,
07                                        //调用await前,当前线程是占有锁的
08  
09 int 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 //被唤醒后,重新开始正式竞争锁,同样,如果竞争不到还是会将自己沉睡,等待唤醒重新开始竞争。
19 if (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方法如下:

1 public 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的实现:

 final void lock() {
            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.html

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

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




0
0
查看评论

Java并发编程系列之十七:Condition接口

通过前面的文章,我们知道任何一个Java对象,都拥有一组监视器方法,主要包括wait()、notify()、notifyAll()方法,这些方法与synchronized关键字配合使用可以实现等待/通知机制。而且前面我们已经使用这种方式实现了生产者-消费者模式。类似地,Condition接口也提供类...
  • u011116672
  • u011116672
  • 2016-04-05 14:50
  • 5244

Java线程(九):Condition-线程通信更高效的方式

接近一周没更新《Java线程》专栏了,主要是这周工作上比较忙,生活上也比较忙,呵呵,进入正题,上一篇讲述了并发包下的Lock,Lock可以更好的解决线程同步问题,使之更面向对象,并且ReadWriteLock在处理同步时更强大,那么同样,线程间仅仅互斥是不够的,还需要通信,本篇的内容是基于上篇之上,...
  • ghsau
  • ghsau
  • 2012-04-20 14:49
  • 74237

java condition使用及分析

背景:     上一篇文章基于object的wait、notify实现了生产者、消费者模式。本篇文章继续梳理Condition。 condition 介绍及demo  Condition是在java 1.5中才出现的,它用来替代传统的Object的wait()、notify(...
  • bohu83
  • bohu83
  • 2016-04-08 17:07
  • 3650

java中的Condition

一、概述 该接口位于java.util.concurrent.locks 声明:public interface Condition  Condition 将 Object 监视器方法(wait、notify 和 notifyAll)分解成截然不同的对象,以便通过将这些对象与任意 ...
  • u010142437
  • u010142437
  • 2015-01-07 16:45
  • 3674

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

Java 并发包下的提供Lock,Lock相对于Synchronized可以更好的解决线程同步问题,更加的灵活和高效,并且ReadWriteLock锁还能实现读、写的分离。但线程间仅仅互斥是不够的,还需要通信,本篇的内容是基于上篇之上,使用Lock如何处理线程通信。阻塞队列(BlockingQueu...
  • chenchaofuck1
  • chenchaofuck1
  • 2016-06-05 23:37
  • 7499

Condition使用总结

一、介绍 Condition是在java 1.5中才出现的,它用来替代传统的Object的wait()、notify()实现线程间的协作,相比使用Object的wait()、notify(),使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。简单说,他...
  • HEYUTAO007
  • HEYUTAO007
  • 2015-11-17 17:14
  • 3043

《Java源码分析》:Condition

《Java源码分析》:Condition如下这篇博文讲解的Condition真心将的好,自己结合了源码也基本上对Condition有了一个大致的了解。写篇博客记录下。参考博客地址如下:http://ifeve.com/understand-condition/。API文档中对Condtion类列出的...
  • u010412719
  • u010412719
  • 2016-08-01 22:01
  • 3150

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

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

Condition java1.8

昨天看了PriorityBlockingQueue,里面有一个Condition notEmpty变量,觉得挺奇怪的,今天,翻一翻API,了解一下。目录 1.Condition是什么 Condition实际上就是将Ojbect对象的监视器(wait,notity)功能抽象出来了,从而...
  • youyou1543724847
  • youyou1543724847
  • 2016-08-10 10:23
  • 237

Java多线程Condition接口原理详解

Condition接口提供了类似Object的监视器方法,与Lock配合可以实现等待/通知模式,但是这两者在使用方式以及功能特性上还是有差别的 Condition接口详解Condition定义了等待/通知两种类型的方法,当前线程调用这些方法时,需要提前获取到Condition对象关联的锁。Cond...
  • fuyuwei2015
  • fuyuwei2015
  • 2017-05-21 19:15
  • 1018
    个人资料
    • 访问:181355次
    • 积分:2976
    • 等级:
    • 排名:第14031名
    • 原创:190篇
    • 转载:19篇
    • 译文:0篇
    • 评论:15条
    文章分类
    最新评论