posts - 40,  comments - 7,  trackbacks - 0
Java多线程－－BusyFlag或Lock

Java语言内置了synchronized关键字用于对多线程进行同步，大大方便了Java中多线程程序的编写。但是仅仅使用synchronized关键字还不能满足对多线程进行同步的所有需要。大家知道，synchronized仅仅能够对方法或者代码块进行同步，如果我们一个应用需要跨越多个方法进行同步，synchroinzed就不能胜任了。在C++中有很多同步机制，比如信号量、互斥体、临届区等。在Java中也可以在synchronized语言特性的基础上，在更高层次构建这样的同步工具，以方便我们的使用。
    当前，广为使用的是由Doug Lea编写的一个Java中同步的工具包，可以在这儿了解更多这个包的详细情况：
    http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html
    该工具包已经作为JSR166正处于JCP的控制下，即将作为JDK1.5的正式组成部分。本文并不打算详细剖析这个工具包，而是对多种同步机制的一个介绍，同时给出这类同步机制的实例实现，这并不是工业级的实现。但其中会参考Doug Lea的这个同步包中的工业级实现的一些代码片断。
    本例中还沿用上篇中的Account类，不过我们这儿编写一个新的ATM类来模拟自动提款机，通过一个ATMTester的类，生成10个ATM线程，同时对John账户进行查询、提款和存款操作。Account类做了一些改动，以便适应本篇的需要：

  1. import  java.util.HashMap;
  2. import  java.util.Map;
  4. class  Account {
  5.     String name;
  6.     //float amount;
  7.     
  8.     //使用一个Map模拟持久存储
  9.     static Map storage = new HashMap();
  10.     static {
  11.         storage.put("John", new Float(1000.0f));
  12.         storage.put("Mike", new Float(800.0f));
  13.     }    
  14.     
  15.     
  16.     public Account(String name) {
  17.         //System.out.println("new account:" + name);
  18.         this.name = name;
  19.         //this.amount = ((Float)storage.get(name)).floatValue();
  20.     }
  22.     public synchronized void deposit(float amt) {
  23.         float amount = ((Float)storage.get(name)).floatValue();
  24.         storage.put(name, new Float(amount + amt));
  25.     }
  27.     public synchronized void withdraw(float amt) throws InsufficientBalanceException {
  28.         float amount = ((Float)storage.get(name)).floatValue();
  29.         if (amount >= amt)
  30.             amount -= amt;
  31.         else 
  32.             throw new InsufficientBalanceException();
  33.                 
  34.         storage.put(name, new Float(amount));
  35.     }
  37.     public float getBalance() {
  38.         float amount = ((Float)storage.get(name)).floatValue();
  39.         return amount;
  40.     }
  41. }



在新的Account类中，我们采用一个HashMap来存储账户信息。Account由ATM类通过login登录后使用：

  1. public  class ATM {
  2.     Account acc;
  3.     
  4.     //作为演示，省略了密码验证
  5.     public boolean login(String name) {
  6.         if (acc != null)
  7.             throw new IllegalArgumentException("Already logged in!");
  8.         acc = new Account(name);
  9.         return true;
  10.     }
  11.     
  12.     public void deposit(float amt) {
  13.         acc.deposit(amt);
  14.     }
  15.     
  16.     public void withdraw(float amt) throws InsufficientBalanceException  {
  17.             acc.withdraw(amt);
  18.     }
  19.     
  20.     public float getBalance() {
  21.         return acc.getBalance();
  22.     }
  23.     
  24.     public void logout () {
  25.         acc = null;
  26.     }
  27.     
  28. }

  29. 下面是ATMTester，在ATMTester中首先生成了10个ATM实例，然后启动10个线程，同时登录John的账户，先查询余额，然后，再提取余额的80％，然后再存入等额的款（以维持最终的余额的不变）。按照我们的预想，应该不会发生金额不足的问题。首先看代码：

    1. public  class ATMTester {
    2.     private static final int NUM_OF_ATM = 10;
    5.     public static void main(String[] args) {
    6.         ATMTester tester = new ATMTester();
    7.         
    8.         final Thread thread[] = new Thread[NUM_OF_ATM];
    9.         final ATM atm[] = new ATM[NUM_OF_ATM];
    10.         for (int i=0; i
    11.             atm[i] = new ATM();
    12.             thread[i] = new Thread(tester.new Runner(atm[i]));
    13.             thread[i].start();
    14.         }    
    15.         
    16.     }
    17.     
    18.     class Runner implements Runnable {
    19.         ATM atm;
    20.         
    21.         Runner(ATM atm) {
    22.             this.atm = atm;
    23.         }
    24.         
    25.         public void run() {
    26.             atm.login("John");
    27.             //查询余额
    28.             float bal = atm.getBalance();
    29.             try {
    30.                 Thread.sleep(1); //模拟人从查询到取款之间的间隔
    31.             } catch (InterruptedException e) {
    32.                 // ignore it
    33.             } 
    34.             
    35.             try {
    36.                 System.out.println("Your balance is:" + bal);
    37.                 System.out.println("withdraw:" + bal * 0.8f);
    38.                 atm.withdraw(bal * 0.8f);
    39.                 System.out.println("deposit:" + bal * 0.8f);
    40.                 atm.deposit(bal * 0.8f);
    41.             } catch (InsufficientBalanceException e1) {
    42.                 System.out.println("余额不足！");
    43.             } finally {
    44.                                     atm.logout();
    45.                            }
    47.         }
    48.     }
    49. }


    运行ATMTester，结果如下（每次运行结果都有所差异）：

    Your balance is:1000.0
    withdraw:800.0
    deposit:800.0
    Your balance is:1000.0
    Your balance is:1000.0
    withdraw:800.0
    withdraw:800.0
    余额不足！
    Your balance is:200.0
    Your balance is:200.0
    Your balance is:200.0
    余额不足！
    Your balance is:200.0
    Your balance is:200.0
    Your balance is:200.0
    Your balance is:200.0
    withdraw:160.0
    withdraw:160.0
    withdraw:160.0
    withdraw:160.0
    withdraw:160.0
    withdraw:160.0
    withdraw:160.0
    deposit:160.0
    余额不足！
    余额不足！
    余额不足！
    余额不足！
    余额不足！
    余额不足！

    为什么会出现这样的情况？因为我们这儿是多个ATM同时对同一账户进行操作，比如一个ATM查询出了余额为1000，第二个ATM也查询出了余额1000，然后两者都期望提取出800，那么只有第1个用户能够成功提出，因为在第1个提出800后，账户真实的余额就只有200了，而第二个用户仍认为余额为1000。这个问题是由于多个ATM同时对同一个账户进行操作所不可避免产生的后果。要解决这个问题，就必须限制同一个账户在某一时刻，只能由一个ATM进行操作。如何才能做到这一点？直接通过synchronized关键字可以吗？非常遗憾！因为我们现在需要对整个Account的多个方法进行同步，这是跨越多个方法的，而synchronized仅能对方法或者代码块进行同步。在下一篇我们将通过编写一个锁对象达到这个目的。

我们首先开发一个BusyFlag的类，类似于C++中的Simaphore。

  1. public  class BusyFlag {
  2.     protected Thread busyflag = null;
  3.     protected int busycount = 0;
  4.     
  5.     public synchronized void getBusyFlag() {
  6.         while (tryGetBusyFlag() == false) {
  7.             try {
  8.                 wait();
  9.             } catch (Exception e) {}            
  10.         }
  11.     }
  12.     
  13.     private synchronized boolean tryGetBusyFlag() {
  14.         if (busyflag == null) {
  15.             busyflag = Thread.currentThread();
  16.             busycount = 1;
  17.             return true;
  18.         }
  19.         
  20.         if (busyflag == Thread.currentThread()) {
  21.             busycount++;
  22.             return true;
  23.         }
  24.         return false;        
  25.     }
  26.     
  27.     public synchronized void freeBusyFlag() {
  28.         if(getOwner()== Thread.currentThread()) {
  29.             busycount--;
  30.             if(busycount==0) {
  31.                 busyflag = null;
  32.                                      notify();
  33.                             }
  34.         }
  35.     }
  36.     
  37.     public synchronized Thread getOwner() {
  38.         return busyflag;
  39.     }
  40. }


注：参考Scott Oaks & Henry Wong《Java Thread》

BusyFlag有3个公开方法：getBusyFlag, freeBusyFlag, getOwner，分别用于获取忙标志、释放忙标志和获取当前占用忙标志的线程。使用这个BusyFlag也非常地简单，只需要在需要锁定的地方，调用BusyFlag的getBusyFlag()，在对锁定的资源使用完毕时，再调用改BusyFlag的freeBusyFlag()即可。下面我们开始改造上篇中的Account和ATM类，并应用BusyFlag工具类使得同时只有一个线程能够访问同一个账户的目标得以实现。首先，要改造Account类，在Account中内置了一个BusyFlag对象，并通过此标志对象对Account进行锁定和解锁：

  1. import  java.util.Collections;
  2. import  java.util.HashMap;
  3. import  java.util.Map;
  5. class  Account {
  6.     String name;
  7.     //float amount;
  8.     
  9.     BusyFlag flag = new BusyFlag();
  10.     
  11.     //使用一个Map模拟持久存储
  12.     static Map storage = new HashMap();
  13.     static {
  14.         storage.put("John", new Float(1000.0f));
  15.         storage.put("Mike", new Float(800.0f));
  16.     }
  17.     
  18.     static Map accounts = Collections.synchronizedMap(new HashMap());    
  19.     
  20.     
  21.     private Account(String name) {
  22.         this.name = name;
  23.         //this.amount = ((Float)storage.get(name)).floatValue();
  24.     }
  25.     
  26.     public synchronized static Account getAccount (String name) {
  27.         if (accounts.get(name) == null)
  28.             accounts.put(name, new Account(name));
  29.         return (Account) accounts.get(name);
  30.     }
  32.     public synchronized void deposit(float amt) {
  33.         float amount = ((Float)storage.get(name)).floatValue();
  34.         storage.put(name, new Float(amount + amt));
  35.     }
  37.     public synchronized void withdraw(float amt) throws InsufficientBalanceException {
  38.         float amount = ((Float)storage.get(name)).floatValue();
  39.         if (amount >= amt)
  40.             amount -= amt;
  41.         else 
  42.             throw new InsufficientBalanceException();
  43.                 
  44.         storage.put(name, new Float(amount));
  45.     }
  47.     public float getBalance() {
  48.         float amount = ((Float)storage.get(name)).floatValue();
  49.         return amount;
  50.     }
  51.     
  52.     public void lock() {
  53.         flag.getBusyFlag();
  54.     }
  55.     
  56.     public void unlock() {
  57.         flag.freeBusyFlag();
  58.     }
  59. }

新的Account提供了两个用于锁定的方法：lock()和unlock()，供Account对象的客户端在需要时锁定Account和解锁Account，Account通过委托给BusyFlag来提供这个机制。另外，大家也发现了，新的Account中提供了对Account对象的缓存，同时去除了public的构造方法，改为使用一个静态工厂方法供用户获取Account的实例，这样做也是有必要的，因为我们希望所有的ATM机同时只能有一个能够对同一个Account进行操作，我们在Account上的锁定是对一个特定Account对象进行加锁，如果多个ATM同时实例化多个同一个user的Account对象，那么仍然可以同时操作同一个账户。所以，要使用这种机制就必须保证Account对象在系统中的唯一性，所以，这儿使用一个Account的缓存，并将Account的构造方法变为私有的。你也可以说，通过在Account类锁上进行同步，即将Account中的BusyFlag对象声明为static的，但这样就使同时只能有一台ATM机进行操作了。这样，在一台ATM机在操作时，全市其它的所有的ATM机都必须等待。
另外必须注意的一点是：Account中的getAccount()方法必须同步，否则，将有可能生成多个Account对象，因为可能多个线程同时到达这个方法，并监测到accounts中没有“John”的Account实例，从而实例化多个John的Account实例。s

ATM类只需作少量改动，在login方法中锁定Account，在logout方法中解锁：

  1. public  class ATM {
  2.     Account acc;
  3.     
  4.     //作为演示，省略了密码验证
  5.     public synchronized boolean login(String name) {
  6.         if (acc != null)
  7.             throw new IllegalArgumentException("Already logged in!");
  8.         acc = Account.getAccount(name);
  9.         acc.lock();
  10.         return true;
  11.     }
  12.     
  13.     public void deposit(float amt) {
  14.         acc.deposit(amt);
  15.     }
  16.     
  17.     public void withdraw(float amt) throws InsufficientBalanceException  {
  18.             acc.withdraw(amt);
  19.     }
  20.     
  21.     public float getBalance() {
  22.         return acc.getBalance();
  23.     }
  24.     
  25.     public synchronized void logout () {
  26.         acc.unlock();
  27.         acc = null;
  28.     }
  29.     
  30. }



ATMTester类不需要做任何修改即可同样运行，同时保证同一个Account同时只能由一个ATM进行操作。解决了上篇提到的多个ATM同时对同一个Account进行操作造成的问题。

在最新的Doug Lea的util.concurrent工具包中（现处于JSR166）提供了类似的并发实用类：ReentrantLock，它实现了java .util.concurrent.locks.Lock接口（将在JDK1.5中发布），它的作用也类似于我们这儿的BusyFlag，实现机制、使用方法也相似。但这是一个工业强度的可重入锁的实现类。在ReentrantLock的API文档中有它的使用示例：

  1.      Lock l = ...; 
  2.      l.lock();
  3.      try {
  4.          // access the resource protected by this lock
  5.      } finally {
  6.          l.unlock();
  7.      }
posted on 2006-08-17 19:30 Lansing 阅读(477) 评论(0)  编辑  收藏 所属分类: Java

只有注册用户登录后才能发表评论。
网站导航:
 
Copyright ©2024 Lansing Powered By: 博客园 模板提供：沪江博客
<2024年11月>
日一二三四五六
272829303112
3456789
10111213141516
17181920212223
24252627282930
1234567

欢迎探讨，努力学习Java哈

常用链接

留言簿(3)

随笔分类

随笔档案

文章分类

文章档案

Lansing's Download

Lansing's Link

我的博客

搜索

  •  

最新评论

阅读排行榜

评论排行榜