java中使用Condition控制线程通信(java疯狂讲义)

如果程序不使用synchronized关键字来保证同步时，而是直接使用Lock对象来保证同步，则系统中不存在隐式的同步监视器，也就不能使用wait（）、notify（）、notifyAll（）方法进行通信了。

当使用Lock对象来保证同步时，java提供了一个Condition类来保持协调，使用Condition可以让哪些已经得到的Lock对象却无法继续执行的线程释放Lock对象，Condition对象也可以唤醒其他处于等待的线程。

Condition将同步监视器方法（wait（）、notify（）、和notifyAll（））分解成截然不同的对象，以便通过将这些对象与Lock对象组合使用，为每个对象提供多个等待集（wait-set）。在这种情况下，Lock替代了同步方法或同步代码块，Condition替代了同步监视器的功能。

Condition实例被绑定在一个Lock对象上，要获得特定的Lock实例的Condition实例，调用Lock对象的newCondition（）方法即可。Condition类提供了如下3个方法。

1、await（）：类似于隐式同步监视器上的wait（）方法，导致当前线程等待，知道其他线程调用该Condition 的signal（）方法或signalAll（）方法来唤醒该线程，该await（）方法有更多的变体，如long awaitNanos（long nanosTimeout）、void awaitUninterruptibly（）、awaitUntil（Data deadline）等，可以完成丰富的等待操作。

2、signal（）：唤醒在此Lock对象上等待的单个线程，如果所有线程都在该Lock对象上等待，则会选择唤醒其中一个线程，选择是任意性的，只有当前线程放弃对Lock对象的锁定后（使用await（）方法），才可以执行被唤醒的线程。

3、signalAll（）：唤醒在此Lock对象上等待的所有线程，只有当前线程放弃对该对象Lock对象的锁定后，才可以执行被唤醒的线程。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionClass{
    public static void main(String[] args){
        Account a=new Account("1",100000);
        ThreadClass t=new ThreadClass(a,1000,"NO1");
        new Thread(new RunnableClass(a,500)).start();
        new Thread(new RunnableClass(a,500)).start();
        new Thread(new RunnableClass(a,500)).start();
    }
}
class Account{
    //显示定义的Lock对象
    private final ReentrantLock lock=new ReentrantLock();
    //获得指定Lock对象对应的Condition
    private final Condition cond=lock.newCondition();
    private String name;
    private double money;
    private boolean flag=false;
    public Account(String name,double money){
        this.name=name;
        this.money=money;
    }
    public double getMoney(){
        return money;
    }
    public void make(double dymoney){
        lock.lock();
        try{
            if(!flag){      
                System.out.println(Thread.currentThread().getName()+"存储了："+dymoney);
                money+=dymoney;
                System.out.println("现在余额为："+money);
                flag=true;
                cond.signalAll();
            }else{
                cond.await();
            }
        }catch(Exception e){System.out.println(e);}finally{
            lock.unlock();
        }
    }
    public void take(double dymoney){
        lock.lock();
        try{
            if(flag){
                System.out.println(Thread.currentThread().getName()+"取走了："+dymoney);
                money-=dymoney;
                flag=false;
                System.out.println("现在余额为："+money);
                cond.signalAll();
            }else{
                cond.await();
            }
        }catch(Exception e){
            System.out.println(e);
        }finally{
            lock.unlock();
        }
    }
}
class ThreadClass extends Thread{
    private Account account;
    private double dymoney;
    private String name;
    public ThreadClass(Account account,double dymoney,String name){
        super(name);
        this.account=account;
        this.dymoney=dymoney;
        start();
    }
    public void run(){
        for(int i=0;i<100;i++){
        account.make(dymoney);
        }
    }
    
}
class RunnableClass implements Runnable{
    private Account account;
    private double dymoney;
    public RunnableClass(Account account,double dymoney){
        this.account=account;
        this.dymoney=dymoney;
    }
    public void run(){
        for(int k=0;k<100;k++){
        try{
        Thread.sleep(1000);
        account.take(dymoney);
        }catch(Exception e){}
        }
    }
}

显示地使用Lock对象来充当同步监视器，则需要使用Condition对象来暂停、唤醒 指定的线程。