Java线程协调运行

傷城~ 2021-09-19 16:10 483阅读 0赞

**一 点睛**

借助于Object类提供的wait()、notify()和notifyAll()三个方法，可实现Java线程协调运行。这三个方法并不属于Thread类，而是属于Object类。但这三个方法必须同步监视器对象调用。

关于这三个方法的解释如下：

*  wait()：导致当前线程等待，直到其他线程调用该同步监视器的notify()方法或notifyAll()方法来唤醒该线程。该wait()方法有三种形式：无时间参数的wait（一直等待，直到其他线程通知），带毫秒参数的wait和带毫秒、微秒参数的wait（这两种方法都是等待指定时间后自动苏醒）。调用wait()方法的当前线程会释放对该同步监视器的锁定。
 *  notify()：唤醒在此同步监视器上等待的单个线程。如果所有线程都在此同步监视器上等待，则会选择唤醒其中一个线程。选择是任意性的。只有当前线程放弃对该同步监视器的锁定后（使用wait()方法），才可以执行被唤醒的线程。
 *  notifyAll()：唤醒在此同步监视器上等待的所有线程。只有当前线程放弃对该同步监视器的锁定后，才可以执行被唤醒的线程。

对于使用synchronized修饰的同步方法，因为该类的默认实例（this）就是同步监视器，所以可以直接调用这三个方法。

对于使用synchronized修饰的同步块，同步监视器是synchronized后括号里的对象，所以必须使用该对象调用这三个方法。

**二 实战**

1 Account类

public class Account
    {
         // 封装账户编号、账户余额的两个成员变量
         private String accountNo;
         private double balance;
         // 标识账户中是否已有存款的旗标
         private boolean flag = false;
         public Account(){}
         // 构造器
         public Account(String accountNo , double balance)
         {
               this.accountNo = accountNo;
               this.balance = balance;
         }
         // accountNo的setter和getter方法
         public void setAccountNo(String accountNo)
         {
               this.accountNo = accountNo;
         }
         public String getAccountNo()
         {
               return this.accountNo;
         }
         // 因此账户余额不允许随便修改，所以只为balance提供getter方法，
         public double getBalance()
         {
               return this.balance;
         }
         public synchronized void draw(double drawAmount)
         {
               try
               {
                    // 如果flag为假，表明账户中还没有人存钱进去，取钱方法阻塞
                    if (!flag)
                    {
                         wait();
                    }
                    else
                    {
                         // 执行取钱
                         System.out.println(Thread.currentThread().getName()
                               + " 取钱:" +  drawAmount);
                         balance -= drawAmount;
                         System.out.println("账户余额为：" +  balance);
                         // 将标识账户是否已有存款的旗标设为false。
                         flag = false;
                         // 唤醒其他线程
                         notifyAll();
                    }
               }
               catch (InterruptedException ex)
               {
                    ex.printStackTrace();
               }
         }
         public synchronized void deposit(double depositAmount)
         {
               try
               {
                    // 如果flag为真，表明账户中已有人存钱进去，则存钱方法阻塞
                    if (flag)             //①
                    {
                         wait();
                    }
                    else
                    {
                         // 执行存款
                         System.out.println(Thread.currentThread().getName()
                               + " 存款:" +  depositAmount);
                         balance += depositAmount;
                         System.out.println("账户余额为：" +  balance);
                         // 将表示账户是否已有存款的旗标设为true
                         flag = true;
                         // 唤醒其他线程
                         notifyAll();
                    }
               }
               catch (InterruptedException ex)
               {
                    ex.printStackTrace();
               }
         }
         // 下面两个方法根据accountNo来重写hashCode()和equals()方法
         public int hashCode()
         {
               return accountNo.hashCode();
         }
         public boolean equals(Object obj)
         {
               if(this == obj)
                    return true;
               if (obj !=null
                    && obj.getClass() == Account.class)
               {
                    Account target = (Account)obj;
                    return target.getAccountNo().equals(accountNo);
               }
               return false;
         }
    }

2 DrawThread线程类

public class DrawThread extends Thread
    {
         // 模拟用户账户
         private Account account;
         // 当前取钱线程所希望取的钱数
         private double drawAmount;
         public DrawThread(String name , Account 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);
               }
         }
    }

3 DepositThread线程类

public class DepositThread extends Thread
    {
         // 模拟用户账户
         private Account account;
         // 当前取钱线程所希望存款的钱数
         private double depositAmount;
         public DepositThread(String name , Account 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);
               }
         }
    }

4 测试类

public class DrawTest
    {
         public static void main(String[] args)
         {
               // 创建一个账户
               Account acct = new Account("1234567" , 0);
               new DrawThread("取钱者" , acct , 800).start();
               new DepositThread("存款者甲" , acct , 800).start();
               new DepositThread("存款者乙" , acct , 800).start();
               new DepositThread("存款者丙" , acct , 800).start();
         }
    }

**三  运行结果**

......
    存款者甲 存款:800.0
    账户余额为：800.0
    取钱者 取钱:800.0
    账户余额为：0.0
    存款者丙 存款:800.0
    账户余额为：800.0
    取钱者 取钱:800.0
    账户余额为：0.0
    存款者甲 存款:800.0
    账户余额为：800.0

**四 说明**

运行该程序，可以看到存款者线程、取钱者线程交替执行的情形，每当存款者向账户中存入800元之后，取钱这线程立即从账户中取出这笔钱。存款完成后账户余额总是800元，取钱结束后账户余额总是0元。

三个存款者线程随机地向账户中存款，只有一个取钱者线程执行取钱操作。只有当取钱者取钱后，存款者才可以存款；同理，只有存款者存款后，取钱这线程才可以取钱。

程序最后被阻塞无法继续向下执行，这是因为3个存款者线程共300次存款操作，但1个取钱者线程只有100次操作，所以程序最后被阻塞。