程序中涉及到对一些共享资源的读和写操作，且写操作没有读操作那么频繁。在没有写操作的时候，两个线程同时读一个资源没有任何问题，所以应该允许多个线程能在同时读取共享资源。但是如果有一个线程想去写这些共享资源，就不应该再有其它线程对该资源进行读或写（译者注：也就是说：读-读能共存，读-写不能共存，写-写不能共存）。这就需要一个读/写锁来解决这个问题。

按照上面的叙述，简单的实现出一个读/写锁

public class ReadWriteLock{  private int readers = 0;  private int writers = 0;  private int writeRequests = 0;  public synchronized void lockRead()      throws InterruptedException{      while(writers > 0 || writeRequests > 0){          wait();      }      readers++;  }  public synchronized void unlockRead(){      readers--;      notifyAll();  }  public synchronized void lockWrite()      throws InterruptedException{      writeRequests++;      while(readers > 0 || writers > 0){          wait();      }      writeRequests--;      writers++;  }  public synchronized void unlockWrite()      throws InterruptedException{      writers--;      notifyAll();  }}

 

 

ReadWriteLock类中，读锁和写锁各有一个获取锁和释放锁的方法。

 

可重入的ReadWriteLock的完整实现

下面是完整的ReadWriteLock实现。为了便于代码的阅读与理解，简单对上面的代码做了重构。重构后的代码如下。

public class ReadWriteLock{ private Map
     
       readingThreads =     new HashMap
      
       (); private int writeAccesses    = 0; private int writeRequests    = 0; private Thread writingThread = null; public synchronized void lockRead()     throws InterruptedException{     Thread callingThread = Thread.currentThread();     while(! canGrantReadAccess(callingThread)){         wait();     }     readingThreads.put(callingThread,         (getReadAccessCount(callingThread) + 1)); } private boolean canGrantReadAccess(Thread callingThread){     if(isWriter(callingThread)) return true;     if(hasWriter()) return false;     if(isReader(callingThread)) return true;     if(hasWriteRequests()) return false;     return true; } public synchronized void unlockRead(){     Thread callingThread = Thread.currentThread();     if(!isReader(callingThread)){         throw new IllegalMonitorStateException(             "Calling Thread does not" +             " hold a read lock on this ReadWriteLock");     }     int accessCount = getReadAccessCount(callingThread);     if(accessCount == 1){         readingThreads.remove(callingThread);     } else {         readingThreads.put(callingThread, (accessCount -1));     }     notifyAll(); } public synchronized void lockWrite()     throws InterruptedException{     writeRequests++;     Thread callingThread = Thread.currentThread();     while(!canGrantWriteAccess(callingThread)){         wait();     }     writeRequests--;     writeAccesses++;     writingThread = callingThread; } public synchronized void unlockWrite()     throws InterruptedException{     if(!isWriter(Thread.currentThread()){     throw new IllegalMonitorStateException(         "Calling Thread does not" +         " hold the write lock on this ReadWriteLock");     }     writeAccesses--;     if(writeAccesses == 0){         writingThread = null;     }     notifyAll(); } private boolean canGrantWriteAccess(Thread callingThread){     if(isOnlyReader(callingThread)) return true;     if(hasReaders()) return false;     if(writingThread == null) return true;     if(!isWriter(callingThread)) return false;     return true; } private int getReadAccessCount(Thread callingThread){     Integer accessCount = readingThreads.get(callingThread);     if(accessCount == null) return 0;     return accessCount.intValue(); } private boolean hasReaders(){     return readingThreads.size() > 0; } private boolean isReader(Thread callingThread){     return readingThreads.get(callingThread) != null; } private boolean isOnlyReader(Thread callingThread){     return readingThreads.size() == 1 &&         readingThreads.get(callingThread) != null; } private boolean hasWriter(){     return writingThread != null; } private boolean isWriter(Thread callingThread){     return writingThread == callingThread; } private boolean hasWriteRequests(){     return this.writeRequests > 0; }}
      
     

应用：线程安全并且高并发状态下的map实现

class RWDictionary {    private final Map
     
       m = new TreeMap
      
       ();    private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();    private final Lock r = rwl.readLock();    private final Lock w = rwl.writeLock();    public Data get(String key) {        r.lock();        try { return m.get(key); }        finally { r.unlock(); }    }    public String[] allKeys() {        r.lock();        try { return m.keySet().toArray(); }        finally { r.unlock(); }    }    public Data put(String key, Data value) {        w.lock();        try { return m.put(key, value); }        finally { w.unlock(); }    }    public void clear() {        w.lock();        try { m.clear(); }        finally { w.unlock(); }    } }