我们先来看看这两个方法的定义:
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方法之后 |
|
收藏
淘帖
踩
