讀操作頻發，寫操作不頻繁。

兩個線程同時讀取同一個共享資源沒有任何問題

如果一個線程對共享資源進行寫操作，此時就不能有其他線程對共享資源進行讀寫

寫操作的優先級高于讀操作，在讀操作頻繁的場景下，如果寫操作沒有高于讀操作的優先級，就會導致寫操作線程“餓死”的情況發生

讀操作觸發條件：

沒有線程正在執行寫操作

沒有線程在等待執行寫操作

寫操作觸發條件：沒有線程正在執行讀寫操作

鎖重入，是指同一線程 外層函數獲得鎖之后 ，內層遞歸函數仍然有獲取該鎖的代碼，但不受影響。ReentrantLock 和synchronized 都是可重入鎖，可重入鎖最大的作用是避免死鎖。
以自旋鎖為例，如果自旋鎖不是可重入鎖的話，如果一個線程在第一次獲取鎖執行同步代碼前提下，第二次再執行同步代碼就產生了死鎖。
以前面的代碼為例：

此時有兩個線程Thread1，Thread2

Thread2在Thread1獲取讀鎖以后請求寫鎖，readers=1、writers=0、writeRequests=1

若此時Thread1再次嘗試獲取同一個讀鎖，根據已有的代碼writers > 0 || writeRequests > 0，因為Thread請求寫鎖的原因導致該條件成立，Thread1進入阻塞狀態，死鎖出現

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;
    }
}

參考文獻
http://ifeve.com/read-write-l...