科技行者

行者学院 转型私董会 科技行者专题报道 网红大战科技行者

知识库

知识库 安全导航

至顶网软件频道基础软件Java多线程同步-BusyFlag或Lock

Java多线程同步-BusyFlag或Lock

  • 扫一扫
    分享文章到微信

  • 扫一扫
    关注官方公众号
    至顶头条

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

作者:中国IT实验室 来源:中国IT实验室 2007年8月28日

关键字: 同步 多线程 java

  • 评论
  • 分享微博
  • 分享邮件

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



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

 

查看本文来源
    • 评论
    • 分享微博
    • 分享邮件
    邮件订阅

    如果您非常迫切的想了解IT领域最新产品与技术信息,那么订阅至顶网技术邮件将是您的最佳途径之一。

    重磅专题
    往期文章
    最新文章