【Java多线程与并发库】04 传统的线程同步通信技术-synchronized/wait/notify/notifyAll

【Java多线程与并发库】04 传统的线程同步通信技术-synchronized/wait/notify/notifyAll

当线程在系统内运行时，线程调度具有一定的透明性，程序通常无法准确控制线程的轮换执行，但我们可以通过一些机制来保证线程协调运行。

我们将通过一个例子学习传统的线程同步通信。
假设系统中有两个线程，分别代表存款者和取款者。系统有一个特殊的要求，每当存款者将钱存入到账户后，取款者立即将钱取出，循环地执行存款、取款，但是不允许存款者连续两次存钱，也不允许取款者连续两次取钱。

为了实现这个功能，可以借助于 Object 类提供的wait()/notify()/notifyAll()这三个方法，它们是Object对象的方法。为了达到同步通信的目的，需要使用同步监视器对象调用这三个方法，而不是Thread类对象调用它们。

解释这三个方法的作用

wait(): 导致当前线程处于等待状态，指导其他线程调用该同步监视器的notify或者notifyAll方法来唤醒该线程

notify()：唤醒在此同步监视器上的等待着的一个线程。

notifyAll()：唤醒在此同步监视器上的等待的所有线程。

下面，我们来实现上述的需求。

程序可以通过一个标识字段来表示是否有存款。
当存钱者要存钱时，先检查是否有存款，如果有，则等待；否则，就存钱，并将标识字段设置为 true，表示已经存款。
当取款者要取钱时，先检查是否有存款，如果没有，则等待；否则，就取钱，并将标识字段设置为 false，表示没有存款。

本程序为Account提供了draw和deposit方法，分别对应取款和存款操作，因为这两个方法可能会并发的修改Account类中的 balance 字段，所以使用synchronized字段修饰同步方法。
这两个方法使用 wait和notify实现通信，进而协作完成任务。

Account程序如下：

/**
 * description:
 *
 * @author liyazhou
 * @since 2017-08-19 14:16
 */
public class Account {
    private String accountNo;
    private double balance;

    private boolean flag = false; // 表示是否有存款

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

    public synchronized void draw(double drawAmount){
        try {
            if (!flag){  // 没有存款，则等待
                this.wait();
            } else{     // 有存款，则进行取钱操作
                balance -= drawAmount;
                flag = false;  // 将账户标识为没有存款的状态
                System.out.println(Thread.currentThread().getName() + " 取钱 " + drawAmount);
                System.out.println(accountNo + " 余额为 " + balance);
                System.out.println("-------------------------\n");

                this.notify();  // 唤醒同一个同步监视器对象上其他的等待着的线程
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


    public synchronized void deposit(double depositAmount){
        try{
            if (flag){   // 有存款，不能再次存款，则等待
                this.wait();
            } else {
                balance += depositAmount;
                flag = true;
                System.out.println(Thread.currentThread().getName() + " 存钱 " + depositAmount);
                System.out.println(accountNo + " 余额为 " + balance);
                System.out.println();

                this.notify();  // 唤醒同一个同步监视器上对象上其他的等待着的线程
            }

        } catch(InterruptedException e){
            e.printStackTrace();
        }
    }
}

下面是存款者执行若干次存钱操作，取款者执行若干次取钱操作
实现如下：

**
 * description:
 *
 * @author liyazhou
 * @since 2017-08-19 14:34
 */

class DrawThread extends Thread{
    private Account acct;
    private double drawAmount;

    public DrawThread(String name, Account acct, double drawAmount){
        super(name);
        this.acct = acct;
        this.drawAmount = drawAmount;
    }

    /**
     * 线程体，执行取款 100 次
     */
    @Override
    public void run(){
        for (int i = 0; i < 5; i ++){
            acct.draw(drawAmount);
        }
    }
}



class DepositThread extends Thread{
    private Account acct;
    private double depositAmount;

    public DepositThread(String name, Account acct, double depositAmount){
        super(name);
        this.acct = acct;
        this.depositAmount = depositAmount;
    }

    @Override
    public void run(){
        for (int j = 0; j < 5; j ++){
            acct.deposit(depositAmount);
        }
    }
}

下面是测试存钱和取钱的操作是否符合系统的要求

public static void main(String... args){
    Account acct = new Account("zhouzhou", 0);
    new DrawThread("取钱者1", acct, 600).start();
    new DepositThread("存钱者甲", acct, 600).start();

//        new DrawThread("取钱者2", acct, 600).start();
//        new DrawThread("取钱者3", acct, 600).start();
//        new DepositThread("存钱者乙", acct, 600).start();
//        new DepositThread("存钱者丙", acct, 600).start();
}

执行结果如下：

存钱者甲 存钱 600.0
zhouzhou 余额为 600.0

取钱者1 取钱 600.0
zhouzhou 余额为 0.0
-------------------------

存钱者甲 存钱 600.0
zhouzhou 余额为 600.0

取钱者1 取钱 600.0
zhouzhou 余额为 0.0
-------------------------

存钱者甲 存钱 600.0
zhouzhou 余额为 600.0

取钱者1 取钱 600.0
zhouzhou 余额为 0.0
-------------------------

存钱者甲 存钱 600.0
zhouzhou 余额为 600.0

取钱者1 取钱 600.0
zhouzhou 余额为 0.0
-------------------------

存钱者甲 存钱 600.0
zhouzhou 余额为 600.0

取钱者1 取钱 600.0
zhouzhou 余额为 0.0

从执行结果可以看出程序循环地执行存钱和取钱操作，满足系统要求。

小结：
一个同步监视器对象调用wait和notify/notifyAll实现线程之间的通信，这中间需要借助变量来表示状态，以协调同一个同步监视器上的各个线程是执行等待还是唤醒操作。
同步监视器是随着synchronized存在的，而通信方法则来自于Object对象。
因此可以说，是synchronized和Object共同完成线程之间的通信。

参考：

《疯狂Java讲义》