Блокировка чтения/записи. Часть 6

Итак, приведем полностью код класса ReadWriteLock, который поддерживает все варианты повторных блокировок:

• для читающих потоков
• для записывающих потоков
• для читающих потоков, получающих также доступ на запись
• для записывающих потоков, получающих также доступ на чтение

Код класса:

public class ReadWriteLock {
  private Map<Thread, Integer> readingThreads = new HashMap<Thread, Integer>();
  private int writers        = 0;
  private int writeRequests  = 0;
  private Thread writingThread;
 
  //
  // read locking
  //
 
  public synchronized void lockRead() throws InterruptedException {
    Thread callingThread = Thread.currentThread();
    while(!canGrantReadAccess(callingThread)) {
      wait();                                                                   
    }
    int accessCount = getReadAccessCount(callingThread);
    readingThreads.put(callingThread,accessCount+1);
  }
 
  public synchronized void unlockRead() {
    Thread callingThread = Thread.currentThread();
    int accessCount = getReadAccessCount(callingThread);
    if(accessCount == 1) { 
      readingThreads.remove(callingThread); 
    } else { 
      readingThreads.put(callingThread, accessCount-1); 
    }
    notifyAll();
  }
 
  private boolean canGrantReadAccess(Thread callingThread) {
    if (isWriter(callingThread)) return true;
    if(writers > 0)              return false;
    if(isReader(callingThread)   return true;
    if(writeRequests > 0)        return false;
    return true;
  }
 
  private int getReadAccessCount(Thread callingThread) {
    Integer accessCount = readingThreads.get(callingThread);
    if(accessCount == null) return 0;
    return accessCount.intValue();
  }
 
  private boolean isReader(Thread callingThread) {
    return readingThreads.get(callingThread) != null;
  }
 
  private boolean hasReaders() {
    return readingThreads.size() > 0;
  }
 
  private boolean isOnlyReader(Thread thread) {
    return readingThreads.size() == 1 && readingThreads.get(thread) != null;
  }
 
  //
  // write locking
  //
 
  public synchronized void lockWrite() throws InterruptedException {
    writeRequests++;
    Thread callingThread = Thread.currentThread();
 
    while(!canGrantWriteAccess(callingThread)){
      wait();
    }
    writeRequests--;
    writers++;
    writingThread = callingThread;
  }
 
  public synchronized void unlockWrite() throws InterruptedException {
    writers--;
    if(writers == 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 boolean isWriter(Thread callingThread) {
    return writingThread == callingThread;
  }
}

Данный класс блокировок можно использовать везде, где требуется синхронизировать читающие и записывающие потоки.