Java多线程同步－BusyFlag或Lock

我们首先开发一个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.      }