java5条件阻塞Condition的应用-多路等待通知Lock-Condition使用-笔记整理10

java5条件阻塞Condition的应用

Condition的功能类似在传统线程技术中的Object.wait和Object.notify的功能。在等待Condition时，允许发生”虚假唤醒”，这通常作为对基础平台语义的让步。对于大多数应用程序，这带来的实际影响很小，因为Condition应该总是在一个循环中被等待，并测试正在等待的状态声明。某个实现可以随意移除可能的虚假唤醒，但建议应用程序程序员总是假定这些虚假唤醒可能发生，因此总是在一个循环中等待。

一个锁内部可以有多个Condition，即有多路等待和通知，可以参看jdk1.5提供的Lock与Condition实现的可阻塞队列的应用案例，从中除了要体会算法，还要体会面向对象的封装。在传统的线程机制中一个监视对象上只能由一路等待和通知，要实现多路等待和通知，必须嵌套使用多个同步监视器对象。(如果只用一个Condition，两个放的都在等，一旦一个放的进去了，那么它通知可能会导致另一个放接着往下走。)

大纲：

(1)用面试宝典中的子线程循环10次和主线程循环5次，两者交替运行50的例子进行讲解。 

(2)参考jdk文档中，Condition对象api中官方给了一种多路等待的阻塞队列代码 

 (3)在子线程和主线程交替循环时候，再加入一个线程，3个线程间交替执行，1执行完通知2,2执行完通知3，3执行完通知1（使用多个Condition来解决多路等待通知）

(1)用面试宝典中的子线程循环10次和主线程循环5次，两者交替运行50的例子进行讲解。

传统方式，使用synchronized来实现线程间互斥，Object自带的this.wait()、this.notify()实现线程间互斥

Jdk1.5之后使用Lock的lock()、unlock()方法实现线程间互斥，Lock.newCondition()的await()、signal()方法来实现线程间的同步

代码示例1：传统方式，使用synchronized来实现线程间互斥，Object自带的this.wait()、this.notify()实现线程间互斥

public class TraditionalThreadCommunication2 {public static void main(String[] args) {final Business business = new Business();new Thread(new Runnable() {@Overridepublic void run() {for(int i=1;i<=50;i++){business.sub(i);}}}).start();for(int i=1;i<=50;i++){business.main(i);}}}  class Business {    private boolean bShouldSub = true;  public synchronized void sub(int i){  while(!bShouldSub){  try {this.wait();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}  }for(int j=1;j<=10;j++){System.out.println("sub thread sequence of " + j + ",loop of " + i);}  bShouldSub = false;  this.notify();  }    public synchronized void main(int i){  while(bShouldSub){  try {this.wait();  } catch (InterruptedException e) {e.printStackTrace();}  }for(int j=1;j<=100;j++){System.out.println("main thread sequence of " + j + ",loop of " + i);}this.notify();bShouldSub = true;  }  }

代码示例2：Jdk1.5之后使用Lock的lock()、unlock()方法实现线程间互斥，Lock.newCondition()的await()、signal()方法来实现线程间的同步

注意使用的是：condition的await()、signal()方法。而不是wait()、notify()方法，这俩个方法都是Object对象中的，是每个对象都有的，要用condition对象自由的等待、唤醒方法。

遇到过一个问题，为什么要将线程的等待，唤醒方法用放到Object祖先类中？

考虑到，所有的类都会被用到锁对象，结合synchronized的原理，其内部都是一个锁对象和一个监听(condition)对象.

                在使用synchronized关键字，其默认的锁对象和监听对象默认是同一个。在synchronized中使用唤醒、等待方法，要使用所对应锁对象的wait()、notify()方法。

 在使用的锁对象代码块中，使用的等待、唤醒方法 不是锁对象对应的监听对象的方法，会报错误：java.lang.IllegalMonitorStateException

public class TraditionalThreadCommunication {public static void main(String[] args) {final Business business = new Business();new Thread(new Runnable() {@Overridepublic void run() {for(int i=1;i<=50;i++){business.sub(i);}}}).start();for(int i=1;i<=50;i++){business.main(i);}}}  class Business {  Lock lock=new ReentrantLock();  Condition condition=lock.newCondition();    private boolean bShouldSub = true;    public void sub(int i){  lock.lock();  try {  while(!bShouldSub){  try {condition.await();  } catch (InterruptedException e) {e.printStackTrace();  }  }for(int j=1;j<=10;j++){System.out.println("sub thread sequence of " + j + ",loop of " + i);}  bShouldSub = false;  condition.signal();  } finally {lock.unlock();  }       }    public  void main(int i){  lock.lock();  try {  while(bShouldSub){  try {//this.wait();condition.await();  } catch (InterruptedException e) {e.printStackTrace();}  }for(int j=1;j<=100;j++){System.out.println("main thread sequence of " + j + ",loop of " + i);}bShouldSub = true;condition.signal();  } finally {lock.unlock();  }  }}

(2)参考jdk文档中，Condition对象api中官方给了一种多路等待的阻塞队列代码 

通过俩个Condition对象来操作缓冲阻塞队列里的数据，

在存放数据的方法中，通过notFull(Condition)来控制操作线程等待，唤醒 取数据 线程

在取数据的方法中，通过notEmpty(Condition)来控制操作线程等待，唤醒 存数据 线程

如果只使用一个Condition来控制线程间的存取，线程之间的唤醒是随机唤醒，如果唤醒的都是取线程（或读线程）会产生死锁

class BoundedBuffer {   final Lock lock = new ReentrantLock();   final Condition notFull  = lock.newCondition();    final Condition notEmpty = lock.newCondition();    final Object[] items = new Object[100];   int putptr, takeptr, count;   public void put(Object x) throws InterruptedException {     lock.lock();     try {       while (count == items.length)          notFull.await();       items[putptr] = x;        if (++putptr == items.length) putptr = 0;       ++count;       notEmpty.signal();     } finally {       lock.unlock();     }   }   public Object take() throws InterruptedException {     lock.lock();     try {       while (count == 0)          notEmpty.await();       Object x = items[takeptr];        if (++takeptr == items.length) takeptr = 0;       --count;       notFull.signal();       return x;     } finally {       lock.unlock();     }   }  }

 (3)在子线程和主线程交替循环时候，再加入一个线程，3个线程间交替执行，1执行完通知2,2执行完通知3，3执行完通知1（使用多个Condition来解决多路等待通知）

通过3个 Condition 和 shouldSub的三个状态 是来同步线程间的等待唤醒次序关系

public class TreeConditionCommunication {public static void main(String[] args) {final Business business = new Business();new Thread(new Runnable() {@Overridepublic void run() {for(int i=1;i<=50;i++){business.sub2(i);}}}).start();new Thread(new Runnable() {@Overridepublic void run() {for(int i=1;i<=50;i++){business.sub3(i);}}}).start();for(int i=1;i<=50;i++){business.main(i);}}  static class Business {  private int shouldSub = 1;   Lock  lock = new ReentrantLock();  Condition condition1 = lock.newCondition();  Condition condition2 = lock.newCondition();  Condition condition3 = lock.newCondition();  public  void sub2(int i){      lock.lock();  try{  while(shouldSub!=2){  try {condition2.await();} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}  }for(int j=1;j<=10;j++){System.out.println("sub2 thread sequence of " + j + ",loop of " + i);}  shouldSub = 3;  condition3.signal();  }  finally{   lock.unlock();  }   } public  void sub3(int i){      lock.lock();  try{  while(shouldSub!=3){  try {condition3.await();} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}  }for(int j=1;j<=20;j++){System.out.println("sub3 thread sequence of " + j + ",loop of " + i);}  shouldSub = 1;  condition1.signal();  }  finally{   lock.unlock();  }   }  public  void main(int i){  try{  lock.lock();  while(shouldSub!=1){  try {condition1.await();} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();}  }for(int j=1;j<=100;j++){System.out.println("main thread sequence of " + j + ",loop of " + i);}shouldSub =2;condition2.signal();  }  finally{  lock.unlock();  }  }  }}