讀操作頻發(fā)，寫(xiě)操作不頻繁。

兩個(gè)線程同時(shí)讀取同一個(gè)共享資源沒(méi)有任何問(wèn)題

如果一個(gè)線程對(duì)共享資源進(jìn)行寫(xiě)操作，此時(shí)就不能有其他線程對(duì)共享資源進(jìn)行讀寫(xiě)

寫(xiě)操作的優(yōu)先級(jí)高于讀操作，在讀操作頻繁的場(chǎng)景下，如果寫(xiě)操作沒(méi)有高于讀操作的優(yōu)先級(jí)，就會(huì)導(dǎo)致寫(xiě)操作線程“餓死”的情況發(fā)生

讀操作觸發(fā)條件：

沒(méi)有線程正在執(zhí)行寫(xiě)操作

沒(méi)有線程在等待執(zhí)行寫(xiě)操作

寫(xiě)操作觸發(fā)條件：沒(méi)有線程正在執(zhí)行讀寫(xiě)操作

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

此時(shí)有兩個(gè)線程Thread1，Thread2

Thread2在Thread1獲取讀鎖以后請(qǐng)求寫(xiě)鎖，readers=1、writers=0、writeRequests=1

若此時(shí)Thread1再次嘗試獲取同一個(gè)讀鎖，根據(jù)已有的代碼writers > 0 || writeRequests > 0，因?yàn)門(mén)hread請(qǐng)求寫(xiě)鎖的原因?qū)е略摋l件成立，Thread1進(jìn)入阻塞狀態(tài)，死鎖出現(xiàn)

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){
     #寫(xiě)鎖降級(jí)到讀鎖的邏輯判斷
     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){
     #讀鎖轉(zhuǎn)換成寫(xiě)鎖的邏輯判斷
     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;
    }
}

參考文獻(xiàn)
http://ifeve.com/read-write-l...