并发——读写锁初探

读操作频发，写操作不频繁。

两个线程同时读取同一个共享资源没有任何问题

如果一个线程对共享资源进行写操作，此时就不能有其他线程对共享资源进行读写

写操作的优先级高于读操作，在读操作频繁的场景下，如果写操作没有高于读操作的优先级，就会导致写操作线程“饿死”的情况发生

读操作触发条件：

没有线程正在执行写操作

没有线程在等待执行写操作

写操作触发条件：没有线程正在执行读写操作

锁重入，是指同一线程 外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码，但不受影响。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...