java 线程wait()与notify()的用法(被唤醒后的线程到底重新执行同步代码块还是从那是等待的那里继续执行)
2012-03-19 23:36 1264人阅读 评论(0) 收藏 举报
javastringclassthreadequalsobject
 
 我们先来看看这两个方法的定义:

      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方法之后