黑马程序员技术交流社区

标题: 多线程并发执行（银行存钱取钱操作） [打印本页]
作者: 李贺晓    时间: 2012-11-21 14:17
标题: 多线程并发执行（银行存钱取钱操作）
//定义银行账户
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次啊？
是哪里出的问题，求解答
作者: 李贺晓    时间: 2012-11-21 17:20
{:soso_e101:}怎么没人解答下
作者: 廖力    时间: 2012-11-21 19:03
本帖最后由 廖力 于 2012-11-21 19:05 编辑

在你的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;

  3. //定义银行账户
  4. class Account {
  5.         private String accountnum;
  6.         private double money;

  8.         Account(String accountnum, double money) {
  9.                 this.accountnum = accountnum;
  10.                 this.money = money;
  11.         }

  13.         public void setAccountnum(String accountnum) {
  14.                 this.accountnum = accountnum;
  15.         }

  17.         public String getAccountnum() {
  18.                 return accountnum;
  19.         }

  21.         public double getMoney() {
  22.                 return this.money;
  23.         }

  25.         public int hashCode() {
  26.                 return accountnum.hashCode();
  27.         }

  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.         }

  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.         }

  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. }

  50. class PullThread extends Thread {
  51.         private Account account;
  52.         private double pullmoney;

  54.         PullThread(String name, Account account, double pullmoney) {
  55.                 super(name);
  56.                 this.account = account;
  57.                 this.pullmoney = pullmoney;
  58.         }

  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. }

  86. class PushThread extends Thread {
  87.         private Account account;
  88.         private double pushmoney;
  89.         private PullThread pt;

  91.         public void setPt(PullThread pt) {
  92.                 this.pt = pt;
  93.         }

  95.         PushThread(String name, Account account, double pushmoney) {
  96.                 super(name);
  97.                 this.account = account;
  98.                 this.pushmoney = pushmoney;
  99.         }

  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.                         }

  116.                 }
  117.         }
  118. }

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

  129.         }
  130. }
复制代码
~


作者: 李贺晓    时间: 2012-11-22 11:30
廖力 发表于 2012-11-21 19:03
在你的run方法中分别加入和打印的结果是
pull 0
push 0

嗯，你这种方法是不错，但是我按照我写的应该也是没问题的啊，也没有造成死锁，但是就是不知道为什么只能存钱取钱各5次，不知道是怎么回事
作者: 徐强    时间: 2012-11-22 14:07
应为当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;

  6.         Account(String accountnum, double money) {
  7.                 this.accountnum = accountnum;
  8.                 this.money = money;
  9.         }

  11.         public void setAccountnum(String accountnum) {
  12.                 this.accountnum = accountnum;
  13.         }

  15.         public String getAccountnum() {
  16.                 return accountnum;
  17.         }

  19.         public double getMoney() {
  20.                 return this.money;
  21.         }

  23.         public int hashCode() {
  24.                 return accountnum.hashCode();
  25.         }

  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.         }

  35.         public synchronized void pullMoney(double pullmoney) {

  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.                 }

  61.         }

  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.         }

  86. }

  88. class PullThread extends Thread {
  89.         private Account account;
  90.         private double pullmoney;

  92.         PullThread() {
  93.         }

  95.         PullThread(String name, Account account, double pullmoney) {
  96.                 super(name);
  97.                 this.account = account;
  98.                 this.pullmoney = pullmoney;
  99.         }

  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. }

  109. class PushThread extends Thread {
  110.         private Account account;
  111.         private double pushmoney;

  113.         PushThread(String name, Account account, double pushmoney) {
  114.                 super(name);
  115.                 this.account = account;
  116.                 this.pushmoney = pushmoney;
  117.         }

  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. }
复制代码




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2