//定义银行账户
class  Account
{
private String accountnum;
private double money;
private boolean flag=false;
Account(String accountnum,double money)
{
  this.accountnum=accountnum;
  this.money=money;
}
public void setAccountnum(String accountnum)
{
  this.accountnum=accountnum;
}
public String getAccountnum()
{
  return accountnum;
}
public double getMoney()
{
  return this.money;
}
public int hashCode()
{
  return accountnum.hashCode();
}
public boolean equals(Object obj)
{
  if(obj!=null && obj.getClass()==Account.class)
  {
   Account a=(Account) obj;
   return a.getAccountnum().equals(accountnum);
  }
  return false;
}
public synchronized void pullMoney(double pullmoney)
{
  
   try
   {
    if(!flag)
    {
     wait();
    }
    else
    {
     System.out.print(Thread.currentThread().getName()+"取钱:"+pullmoney);
     money=money-pullmoney;
     System.out.println(",账户余额为："+money);
     flag=false;
     notifyAll();
    }
   }
   catch (InterruptedException e)
   {
    e.printStackTrace();
   }
   
}
public synchronized void pushMoney(double pushmoney)
{
  try
  {
   if(flag)
   {
    wait();
   }
   else
   {
    System.out.print(Thread.currentThread().getName()+"存钱:"+pushmoney);
    money=money+pushmoney;
    System.out.println(",账户余额为："+money);
    flag=true;
    notifyAll();
   }
  }
  catch (InterruptedException e)
  {
   e.printStackTrace();
  }
}

}
class PullThread extends Thread
{
private Account account;
private double pullmoney;
PullThread(){}
PullThread(String name,Account account,double pullmoney)
{
  super(name);
  this.account=account;
  this.pullmoney=pullmoney;
}
public void run()
{
  for(int i=0;i<10;i++)
  {
   account.pullMoney(pullmoney);
  }
}
}
class PushThread extends Thread
{
private Account account;
private double pushmoney;
PushThread(String name,Account account,double pushmoney)
{
  super(name);
  this.account=account;
  this.pushmoney=pushmoney;
}
public void run()
{
  for(int i=0;i<10;i++)
  {
   account.pushMoney(pushmoney);
  }
}
}
class Test2
{
public static void main(String[] args)
{
  Account a=new Account("123456",0);
  PullThread p=new PullThread("甲取钱",a,500);
  p.start();
  PushThread p1=new PushThread("已存钱",a,500);
  
  p1.start();
  
}
}
我设置的是存钱取钱个10次，但是运行后，为什么是存钱取钱各5次啊？
是哪里出的问题，求解答

{:soso_e101:}怎么没人解答下

在你的run方法中分别加入

1. System.out.println("push " + i);

复制代码

和

1. System.out.println("pull " + i);

复制代码

打印的结果是
pull 0
push 0
已存钱存钱:500.0,账户余额为：500.0
push 1
甲取钱取钱:500.0,账户余额为：0.0
pull 1
push 2
已存钱存钱:500.0,账户余额为：500.0
push 3
pull 2
甲取钱取钱:500.0,账户余额为：0.0
pull 3
push 4
已存钱存钱:500.0,账户余额为：500.0
push 5
pull 4
甲取钱取钱:500.0,账户余额为：0.0
pull 5
push 6
已存钱存钱:500.0,账户余额为：500.0
push 7
pull 6
甲取钱取钱:500.0,账户余额为：0.0
pull 7
push 8
已存钱存钱:500.0,账户余额为：500.0
push 9
pull 8
甲取钱取钱:500.0,账户余额为：0.0
pull 9


具体原因我也不知道为什么
但是最好把wait sleep直接放在run方法里面
还有notifyAll尽量少用 因为容易出先java.lang.IllegalMonitorStateException的异常
下面是我改的 不知道你是不是这个意思...

1. package com.test5;
   
2. 
   
3. //定义银行账户
   
4. class Account {
   
5.         private String accountnum;
   
6.         private double money;
   
7. 
   
8.         Account(String accountnum, double money) {
   
9.                 this.accountnum = accountnum;
   
10.                 this.money = money;
    
11.         }
    
12. 
    
13.         public void setAccountnum(String accountnum) {
    
14.                 this.accountnum = accountnum;
    
15.         }
    
16. 
    
17.         public String getAccountnum() {
    
18.                 return accountnum;
    
19.         }
    
20. 
    
21.         public double getMoney() {
    
22.                 return this.money;
    
23.         }
    
24. 
    
25.         public int hashCode() {
    
26.                 return accountnum.hashCode();
    
27.         }
    
28. 
    
29.         public boolean equals(Object obj) {
    
30.                 if (obj != null && obj.getClass() == Account.class) {
    
31.                         Account a = (Account) obj;
    
32.                         return a.getAccountnum().equals(accountnum);
    
33.                 }
    
34.                 return false;
    
35.         }
    
36. 
    
37.         public synchronized void pullMoney(double pullmoney) {
    
38.                 System.out.print(Thread.currentThread().getName() + "取钱:" + pullmoney);
    
39.                 money = money - pullmoney;
    
40.                 System.out.println(",账户余额为：" + money);
    
41.         }
    
42. 
    
43.         public synchronized void pushMoney(double pushmoney) {
    
44.                 System.out.print(Thread.currentThread().getName() + "存钱:" + pushmoney);
    
45.                 money = money + pushmoney;
    
46.                 System.out.println(",账户余额为：" + money);
    
47.         }
    
48. }
    
49. 
    
50. class PullThread extends Thread {
    
51.         private Account account;
    
52.         private double pullmoney;
    
53. 
    
54.         PullThread(String name, Account account, double pullmoney) {
    
55.                 super(name);
    
56.                 this.account = account;
    
57.                 this.pullmoney = pullmoney;
    
58.         }
    
59. 
    
60.         public void run() {
    
61.                 for (int i = 0; i < 10;) {
    
62.                         if (account.getMoney() >= pullmoney) {
    
63.                                 account.pullMoney(pullmoney);
    
64.                                 i++;
    
65.                                 long time = System.currentTimeMillis();
    
66.                                 try {
    
67.                                         Thread.sleep(333);
    
68.                                 } catch (InterruptedException e) {
    
69.                                         e.printStackTrace();
    
70.                                 }
    
71.                                 time = System.currentTimeMillis() - time;
    
72.                                 System.out.println("第" + i + "次取钱耗时" + time + "毫秒");
    
73.                         } else {
    
74.                                 synchronized (this) {
    
75.                                         try {
    
76.                                                 wait();
    
77.                                         } catch (InterruptedException e) {
    
78.                                                 e.printStackTrace();
    
79.                                         }
    
80.                                 }
    
81.                         }
    
82.                 }
    
83.         }
    
84. }
    
85. 
    
86. class PushThread extends Thread {
    
87.         private Account account;
    
88.         private double pushmoney;
    
89.         private PullThread pt;
    
90. 
    
91.         public void setPt(PullThread pt) {
    
92.                 this.pt = pt;
    
93.         }
    
94. 
    
95.         PushThread(String name, Account account, double pushmoney) {
    
96.                 super(name);
    
97.                 this.account = account;
    
98.                 this.pushmoney = pushmoney;
    
99.         }
    
100. 
     
101.         public void run() {
     
102.                 for (int i = 0; i < 10; i++) {
     
103.                         account.pushMoney(pushmoney);
     
104.                         long time = System.currentTimeMillis();
     
105.                         try {
     
106.                                 Thread.sleep(1000);
     
107.                         } catch (InterruptedException e) {
     
108.                                 e.printStackTrace();
     
109.                         }
     
110.                         time = System.currentTimeMillis() - time;
     
111.                         System.out.println("第" + i + "次存钱耗时" + time + "毫秒");
     
112.                         synchronized (pt) {
     
113.                                 pt.notify();
     
114.                         }
     
115. 
     
116.                 }
     
117.         }
     
118. }
     
119. 
     
120. public class Test2 {
     
121.         public static void main(String[] args) {
     
122.                 Account a = new Account("123456", 0);
     
123.                 PushThread p1 = new PushThread("乙存钱", a, 500);
     
124.                 PullThread p2 = new PullThread("甲取钱", a, 500);
     
125.                 p1.setPt(p2);
     
126.                 p1.start();
     
127.                 p2.start();
     
128. 
     
129.         }
     
130. }

复制代码

~

廖力 发表于 2012-11-21 19:03
在你的run方法中分别加入和打印的结果是
pull 0
push 0

嗯，你这种方法是不错，但是我按照我写的应该也是没问题的啊，也没有造成死锁，但是就是不知道为什么只能存钱取钱各5次，不知道是怎么回事

应为当wait()线程被唤醒后，这个线程没什么要做的就直接结束了，所以只打印出5次。你在wait()后面加上

1. System.out.print(Thread.currentThread().getName() + "取钱:"
   
2.                                                 + pullmoney);
   
3.                                 money = money - pullmoney;
   
4.                                 System.out.println(",账户余额为：" + money);
   
5.                                 flag = false;
   

复制代码

段代码就能打印10次

1. class Account {
   
2.         private String accountnum;
   
3.         private double money;
   
4.         private boolean flag = false;
   
5. 
   
6.         Account(String accountnum, double money) {
   
7.                 this.accountnum = accountnum;
   
8.                 this.money = money;
   
9.         }
   
10. 
    
11.         public void setAccountnum(String accountnum) {
    
12.                 this.accountnum = accountnum;
    
13.         }
    
14. 
    
15.         public String getAccountnum() {
    
16.                 return accountnum;
    
17.         }
    
18. 
    
19.         public double getMoney() {
    
20.                 return this.money;
    
21.         }
    
22. 
    
23.         public int hashCode() {
    
24.                 return accountnum.hashCode();
    
25.         }
    
26. 
    
27.         public boolean equals(Object obj) {
    
28.                 if (obj != null && obj.getClass() == Account.class) {
    
29.                         Account a = (Account) obj;
    
30.                         return a.getAccountnum().equals(accountnum);
    
31.                 }
    
32.                 return false;
    
33.         }
    
34. 
    
35.         public synchronized void pullMoney(double pullmoney) {
    
36. 
    
37.                 try {
    
38.                         if (!flag) {
    
39.                                 System.out.println("取钱等待");
    
40.                                 wait();
    
41.                                 //线程被唤醒后要做的事
    
42.                                 System.out.println("取钱激活");
    
43.                                 System.out.print(Thread.currentThread().getName() + "取钱:"
    
44.                                                 + pullmoney);
    
45.                                 money = money - pullmoney;
    
46.                                 System.out.println(",账户余额为：" + money);
    
47.                                 flag = false;
    
48.                        
    
49.                         } else {
    
50.                                 System.out.print(Thread.currentThread().getName() + "取钱:"
    
51.                                                 + pullmoney);
    
52.                                 money = money - pullmoney;
    
53.                                 System.out.println(",账户余额为：" + money);
    
54.                                 flag = false;
    
55.                                 notifyAll();
    
56.                         }
    
57.                 } catch (InterruptedException e) {
    
58.                         e.printStackTrace();
    
59.                 }
    
60. 
    
61.         }
    
62. 
    
63.         public synchronized void pushMoney(double pushmoney) {
    
64.                 try {
    
65.                         if (flag) {
    
66.                                 wait();
    
67.                                 //线程被唤醒后要做的事
    
68.                                 System.out.print(Thread.currentThread().getName() + "存钱:"
    
69.                                                 + pushmoney);
    
70.                                 money = money + pushmoney;
    
71.                                 System.out.println(",账户余额为：" + money);
    
72.                                 flag = true;
    
73.                         } else {
    
74.                                 System.out.print(Thread.currentThread().getName() + "存钱:"
    
75.                                                 + pushmoney);
    
76.                                 money = money + pushmoney;
    
77.                                 System.out.println(",账户余额为：" + money);
    
78.                                 flag = true;
    
79.                                 notifyAll();
    
80.                         }
    
81.                 } catch (InterruptedException e) {
    
82.                         e.printStackTrace();
    
83.                 }
    
84.         }
    
85. 
    
86. }
    
87. 
    
88. class PullThread extends Thread {
    
89.         private Account account;
    
90.         private double pullmoney;
    
91. 
    
92.         PullThread() {
    
93.         }
    
94. 
    
95.         PullThread(String name, Account account, double pullmoney) {
    
96.                 super(name);
    
97.                 this.account = account;
    
98.                 this.pullmoney = pullmoney;
    
99.         }
    
100. 
     
101.         public void run() {
     
102.                 for (int j = 0; j < 10; j++) {
     
103.                         account.pullMoney(pullmoney);
     
104.                         System.out.println("----"+Thread.currentThread().getName().toString());
     
105.                 }
     
106.         }
     
107. }
     
108. 
     
109. class PushThread extends Thread {
     
110.         private Account account;
     
111.         private double pushmoney;
     
112. 
     
113.         PushThread(String name, Account account, double pushmoney) {
     
114.                 super(name);
     
115.                 this.account = account;
     
116.                 this.pushmoney = pushmoney;
     
117.         }
     
118. 
     
119.         public void run() {
     
120.                 for (int i = 0; i < 10; i++) {
     
121.                         account.pushMoney(pushmoney);
     
122.                         System.out.println("----"+Thread.currentThread().getName());
     
123.                 }
     
124.         }
     
125. }

复制代码