使用Condition配合await()和signal()实现等待/通知

关键字Synchronized与wait()和notify()/notifyAll()结合可以实现“等待/通知”模式，

Lock类的子类ReentrantLock也可以实现同样的功能，但需要借助Condition对象。

优势：在一个Lock对象里面可以创建多个Condition（即对象监视器）实例，

线程对象可以注册在指定的Condition中，从而可以有选择性地对指定线程进行通知，

在调度线程上更加灵活。

实例如下：

需要下面四个类：

封装的业务方法类：MyService.java

线程A类和线程B类：ThreadA.java和ThreadB.java

运行类：Run.java

1、MyService.java

package Condition;

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

public class MyService {

private Lock lock = new ReentrantLock();

public Condition conditionA = lock.newCondition();//创建conditionA对象
public Condition conditionB = lock.newCondition();//创建conditionB对象

public void awaitA(){
try{
lock.lock();//事前加lock，保证线程同步，相当于Synchronized作用
System.out.println("begin awaitA:"+System.currentTimeMillis()+" ThreadName="+Thread.currentThread().getName());
conditionA.await();//进入等待，需要被通知才能继续运行下面代码，绑定conditionA对象
System.out.println(" end awaitA:"+System.currentTimeMillis()+" ThreadName="+Thread.currentThread().getName());
}catch(Exception e){
e.printStackTrace();
}finally{
lock.unlock();//最后不忘unlock()
}
}

public void awaitB(){
try{
lock.lock();
System.out.println("begin awaitB:"+System.currentTimeMillis()+" ThreadName="+Thread.currentThread().getName());
conditionB.await();//进入等待，需要被通知才能继续运行下面代码，绑定conditionB对象
System.out.println(" end awaitB:"+System.currentTimeMillis()+" ThreadName="+Thread.currentThread().getName());
}catch(Exception e){
e.printStackTrace();
}finally{
lock.unlock();
}
}

public void signalAll_A(){

try{
lock.lock();
System.out.println(" signalAll_A:"+System.currentTimeMillis()+" ThreadName="+Thread.currentThread().getName());
conditionA.signalAll();//选择性地通知唤醒所有绑定conditionA的对象
}catch(Exception e){
e.printStackTrace();
}finally{
lock.unlock();
}

}

public void signalAll_B(){

try{
lock.lock();
System.out.println(" signalAll_B:"+System.currentTimeMillis()+" ThreadName="+Thread.currentThread().getName());
conditionB.signalAll();//选择性地通知唤醒所有绑定conditionA的对象
}catch(Exception e){
e.printStackTrace();
}finally{
lock.unlock();
}

}

}

2、ThreadA.java

package Condition;

public class ThreadA extends Thread{

private MyService service;

public ThreadA(MyService service){
super();
this.service = service;
}

@Override
public void run(){
service.awaitA();//调用MyService里的awaitA()方法
}
}

3、ThreadB.java

package Condition;

public class ThreadB extends Thread{

private MyService service;

public ThreadB(MyService service){
super();
this.service = service;
}

@Override
public void run(){
service.awaitB();//调用MyService里的awaitB()方法
}
}

4、Run.java

package Condition;

public class Run {

public static void main(String[] args) {

MyService service = new MyService();
ThreadA a = new ThreadA(service);
a.setName("线程A");
a.start();

ThreadB b = new ThreadB(service);
b.setName("线程B");
b.start();

try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
service.signalAll_A();//通知唤醒绑定ConditionA的线程，使其代码继续执行
}

}