ReentrantLock使用Condition实现通知部分线程

关键字synchronized与wait()和notify()/notifyAll()方法想结合可以实现等待/通知模式，类ReentrantLock也可以实现同样的功能，但需要借助于Condition对象。Condition类在JDK5中出现，使用它有更好的灵活性，比如可以实现多路通知的功能，也就是在一个Lock对象中可以创建多个Condition对象（对象监视器），线程对象可以注册在指定的Condition中，从而可以有选择地进行线程通知，在调度线程上更加灵活。

编程举例：
Service类，包含等待和通知的同步方法。

package lock;

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();
    public Condition conditionB = lock.newCondition();

    public void awaitA(){
        try{
            lock.lock();
            System.out.println("thread "+Thread.currentThread().getName()+" wait begin,in awaitA method");
            conditionA.await(); //使用conditionA进行等待
            System.out.println("thread "+Thread.currentThread().getName()+" end wait,in awaitA method");
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void awaitB(){
        try{
            lock.lock();
            System.out.println("thread "+Thread.currentThread().getName()+" wait begin,in awaitB method");
            conditionB.await();   //使用conditionB进行等待
            System.out.println("thread "+Thread.currentThread().getName()+" end wait,in awaitB method");
        }catch (InterruptedException e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void signalAll_A(){
        try{
            lock.lock();
            System.out.println("现在要通知所在在conditionA上等待的线程 "+Thread.currentThread().getName());
            conditionA.signalAll();  //通知所有在conditionA上等待的线程
        }finally {
            lock.unlock();
        }
    }
    public void signalAll_B(){
        try{
            lock.lock();
            System.out.println("现在要通知所在在conditionB上等待的线程 "+Thread.currentThread().getName());
            conditionB.signalAll();
        }finally {
            lock.unlock();
        }
    }
}

线程A类，A类线程使用conditionA进行等待。

package lock;

public class ThreadA extends Thread{

    private MyService service;

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

    @Override
    public void run(){
        service.awaitA();
    }
}

B类线程，B类线程使用conditionB进行等待。

package lock;

public class ThreadB extends Thread{

    private MyService service;

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

    @Override
    public void run(){
        service.awaitB();
    }
}

测试类，调用Service类的signalAll_A方法，只通知在conditionA上等待的线程：

package lock;

public class Run {

    public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();
        ThreadB b = new ThreadB(service);
        b.setName("B");
        b.start();
        Thread.sleep(3000);
        service.signalAll_A();  //只通知在conditionA上等待的线程。
    }
}

程序输出如下：

thread A wait begin,in awaitA method
thread B wait begin,in awaitB method
现在要通知所在在conditionA上等待的线程 main
thread A end wait,in awaitA method

由此可见线程B没有被唤醒。

在使用Condition实现等待通知时：
Object类中的wait（）方法相当于Condition类的await（）方法。
Object类中的wait(long timeout)方法相当于Condition类中的await(long time,TimeUnit unit)方法。
Object类中的notify()方法相当于Condition类中的signal()方法。
Object类中的notifyAll()方法相当于Condition类中的signalAll()方法。

参考《Java多线程编程核心技术》