多线程总结五：线程通信（一）

当线程在程序中运行时，线程的调度具有一定的透明性，程序通常无法准确控制线程的轮换执行，Java提供了一些机制来保证线程协调运行。

1、传统的线程通信借助Object类提供的wait()、notify()和notifyAll()三个方法，这三个方法必须由同步监视器对象来调用。
a、wait()：导致当前线程等待，直到其他线程调用该同步监视器的notify()方法或notifyAll()方法来唤醒该线程；
b、notify()：唤醒在此同步监视器上等待的单个线程；
c、notifyAll()：唤醒在此同步监视器上等待的所有线程；

2、模拟情景：系统中有两个线程，分别代表存款者和取款者。系统要求存款者和取款者不断重复存款和取款的动作，而且要求每当存款者将钱存入指定账户后，取款者就立即取出该笔钱。不允许存款者连续两次存钱，也不允许取钱者连续两次取钱。

/**
 * @Title: Account3.java 
 * @Package  
 * @author 任伟
 * @date 2014-12-8 下午6:50:34 
 * @version V1.0  
 */

/**
 * @ClassName: Account3
 * @Description: 线程安全Account类,提供存钱和取钱的操作
 * @author 任伟
 * @date 2014-12-8 下午6:50:34
 */
public class Account3 {
    private String accountNo; // 账户编号
    private double balance; // 账户余额
    private boolean flag = false; // 表示账户中是否已有存款的骑标

    public String getAccountNo() {
        return accountNo;
    }

    public void setAccountNo(String accountNo) {
        this.accountNo = accountNo;
    }

    public double getBalance() {
        return balance;
    }

    public Account3() {
        super();
    }

    public Account3(String accountNo, double balance) {
        super();
        this.accountNo = accountNo;
        this.balance = balance;
    }

    public boolean equals(Object anObject) {
        if (this == anObject)
            return true;
        if (anObject != null && anObject.getClass() == Account.class) {
            Account target = (Account) anObject;
            return target.getAccountNo().equals(accountNo);
        }
        return false;
    }

    public int hashCode() {
        return accountNo.hashCode();
    }

    // 取钱操作
    public synchronized void draw(double drawAmount) {
        try {
            if (!flag) {//如果flag为假，表明账户中还没有人存钱进去，取钱方法阻塞
                wait();
            } else {//否则就进行取钱操作
                if (balance >= drawAmount) {
                    System.out.println(Thread.currentThread().getName()
                            + "取钱成功，吐出钞票：" + drawAmount);
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    balance -= drawAmount;
                    System.out.println("余额为：" + balance);
                } else {
                    System.out.println(Thread.currentThread().getName()
                            + "取钱失败！余额不足！");
                }
                //将账户是否已有存款的旗标设为false
                flag = false;
                //唤醒其他进程
                notifyAll();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    //存钱操作
    public synchronized void deposit(double depositAmount){
        try{
            if(flag){//如果flag为真，表明账户中已有人存钱进去，存钱方法阻塞
                wait();
            }else{
                //执行存款操作
                System.out.println(Thread.currentThread().getName()+" 存款：" +depositAmount);
                balance += depositAmount;
                System.out.println("账户余额为：" + balance);
                //将账户是否已有存款的旗标设为true
                flag=true;
                notifyAll();
                
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/**
 * @Title: DrawDepositTest3.java 
 * @Package  
 * @author 任伟
 * @date 2014-12-9 下午2:09:38 
 * @version V1.0  
 */

/** 
 * @ClassName: DrawDepositTest3 
 * @Description: 测试存款和取款线程
 * @author 任伟
 * @date 2014-12-9 下午2:09:38  
 */
public class DrawDepositTest3 {
    public static void main(String[] args) {
        Account3 acct = new Account3("1234567", 0);
        new DrawThread3("取钱者", acct, 800).start();
        new DepositThread3("存钱者甲", acct, 800).start();
        new DepositThread3("存钱者乙", acct, 800).start();
        new DepositThread3("存钱者丙", acct, 800).start();
    }
}

//取款线程
class DrawThread3 extends Thread{
    private Account3 account;    //模拟用户账户
    private double drawAmount;  //取钱数
    
    public DrawThread3(String name, Account3 account, double drawAmount) {
        super(name);
        this.account = account;
        this.drawAmount = drawAmount;
    }
    
    //重复100次执行取钱操作
    public void run(){
        for(int i=0; i<100; i++){
            account.draw(drawAmount);
        }
    }    
}

//春款线程
class DepositThread3 extends Thread{
    private Account3 account;    //模拟用户账户
    private double depositAmount;  //存钱数
    
    public DepositThread3(String name, Account3 account, double depositAmount) {
        super(name);
        this.account = account;
        this.depositAmount = depositAmount;
    }
    
    //重复100次执行存钱操作
    public void run(){
        for(int i=0; i<100; i++){
            account.deposit(depositAmount);
        }
    }
    
    
}

Result

如图所示的阻塞并不是死锁，取钱者线程已经执行结束，而存款者线程只是在等待其他线程来取钱而已，并不是等待其他线程释放同步监视器。