A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

我们先来看看这两个方法的定义:

      wait()   导致当前线程等待,直到其他线程调用此对象的 notify()方法或 notifyAll()方法前,导致当前线程等待。

     notify()  唤醒在此同步监视器上等待的单个线程,如果有多个线程在此同步监视器上等待,则会唤醒其中的一个,



现在假设系统有以一种特殊的要求,系统要求存款者和取款者不断的重复存钱,取钱动作,而且要求每当存款者将存入指定帐号后,取钱者就立即取出该笔钱,不容许存钱者连续两次存钱,也不容许取前者两次取钱,

实现的代码如下:

本程序通过 Account类提供draw与depost两个方法,分别对应该帐户的取钱与存钱操作
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;
}

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

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();
  }
}

public int hashCode()
{
  return accountNo.hashCode();
}
public boolean equals(Object obj)
{
  if (obj != null && obj.getClass() == Account.class)
  {
   Account target = (Account)obj;
   return target.getAccountNo().equals(accountNo);
  }
  return false;
}
}

程序中的存钱者线程循环一百次重复存钱,而取前者则循环一百此取钱,存钱者线程,取款这线程分别调用Account对象的deposit,draw方法实现

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);
  }
}
}

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);
  }  
}
}

主程序可以启动任意多余条存款和取款线程,可以看到所有取钱线程必须等存款线程存钱后才可以向下执行,而存款线程也必须等待取钱线程取钱后才可以向下执行,主程序代码如下;

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

}

现在我们步入正题,当一个线程等待被唤醒之后开始执行的地方,这问题曾今也困惑了我好一段时间,

下面我们来将下面的方法里面的代码改一改

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  int   in = 0 ;

public synchronized void draw(double drawAmount)

{  

System.out.println(" 进入 synchronized void draw");
  
  try
  { //如果flag为假,表明账户中还没有人存钱进去,则取钱方法阻塞
   if (!flag)
   {//AtomicInteger
       in++;

    //将当前线程重命名
     Thread.currentThread().setName("取钱者AAAAAAAAAAAAAAAAAAA"+" "+in);
     System.out.println(Thread.currentThread().getName() +
      " 阻塞");
     wait();
   }
   else
   {   
    //执行取钱
    System.out.println(Thread.currentThread().getName() +
     " 取钱:" +  drawAmount);
    balance -= drawAmount;
    System.out.println("取钱成功--------------------取户余额为======================" + balance);
    //将标识账户是否已有存款的旗标设为false。
    flag = false;
    //唤醒其他线程
    System.out.println("                    ======取款唤醒其他线程                         ");
   
    notifyAll();
   }
  System.out.println("这人民共和国==========这人民共和国=====这人民共和国");
  }
  catch (InterruptedException ex)
  {
   ex.printStackTrace();
  }
}
现在我们来想象一下程序的运行,我们像是启动了一个取款者线程,也就是说当我们帐户上还没有前的时候就去取钱,你想象那银行肯定是不干的咯,所以它会进入等待,进入等待之后我们将它给重命名(末尾加上了一个数字,这数字代表进入等待的次数),它进入等待之后在等待者存款线程改变它的状态,并且等待者要它用notfy()来将它唤醒,现在我们假设它有两种执行状况

(1):被唤醒之后从新从该同步代码块执行,此时控制台会输出“进入 synchronized    void draw”此时它应该进入

     else()块内,也就是说它现在应该就可以取钱了,然后看到控制台输出"这人民共和国==========这人民共和国

     =====这人民共和国",

(2):继续从等待的地方(wait()方法之后)执行,又由于if与else是相对立的,所以它不会进入else里面,所以线程这

     次 进入线程是空着手出去的(取钱没有成功),所以你会看到控制台输出"这人民共和国==========这人民共和国

     =====这人民共和国",然后在输出“进入 synchronized  void draw”然后在进行取钱操作,



而事实确实如第二种情况;

所以总结有:



在Java对象中,有两种池
琐池-----------------------synchronized
等待池---------------------wait(),notify(),notifyAll()
如果一个线程调用了某个对象的wait方法,那么该线程进入到该对象的等待池中(并且已经将锁释放),
如果未来的某一时刻,另外一个线程调用了相同对象的notify方法或者notifyAll方法,
那么该等待池中的线程就会被唤起,然后进入到对象的锁池里面去获得该对象的锁,
如果获得锁成功后,那么该线程就会沿着wait方法之后的路径继续执行。注意是沿着wait方法之后

2 个回复

倒序浏览
不错的测试实例
回复 使用道具 举报
sisel 发表于 2015-4-15 13:56
不错的测试实例

谢谢!:P
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马