【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讲义》