/**
相比Java中的锁(Locks in Java)里Lock实现，读写锁更复杂一些。假设你的程序中涉及到对一些共享资源的读和写操作，且写操作没有读操作那么频繁。在没有写操作的时候，两个线程同时读一个资源没有任何问题，所以应该允许多个线程能在同时读取共享资源。但是如果有一个线程想去写这些共享资源，就不应该再有其它线程对该资源进行读或写（译者注：也就是说：读-读能共存，读-写不能共存，写-写不能共存）。这就需要一个读/写锁来解决这个问题。
Java5在java.util.concurrent包中已经包含了读写锁。尽管如此，我们还是应该了解其实现背后的原理。
以下是本文的主题
读/写锁的Java实现(Read / Write Lock Java Implementation)
读/写锁的重入(Read / Write Lock Reentrance)
读锁重入(Read Reentrance)
写锁重入(Write Reentrance)
读锁升级到写锁(Read to Write Reentrance)
写锁降级到读锁(Write to Read Reentrance)
可重入的ReadWriteLock的完整实现(Fully Reentrant ReadWriteLock)
在finally中调用unlock() (Calling unlock() from a finally-clause)
读/写锁的Java实现
先让我们对读写访问资源的条件做个概述：
读取 没有线程正在做写操作，且没有线程在请求写操作。
写入 没有线程正在做读写操作。
如果某个线程想要读取资源，只要没有线程正在对该资源进行写操作且没有线程请求对该资源的写操作即可。我们假设对写操作的请求比对读操作的请求更重要，就要提升写请求的优先级。此外，如果读操作发生的比较频繁，我们又没有提升写操作的优先级，那么就会产生“饥饿”现象。请求写操作的线程会一直阻塞，直到所有的读线程都从ReadWriteLock上解锁了。如果一直保证新线程的读操作权限，那么等待写操作的线程就会一直阻塞下去，结果就是发生“饥饿”。因此，只有当没有线程正在锁住ReadWriteLock进行写操作，且没有线程请求该锁准备执行写操作时，才能保证读操作继续。
当其它线程没有对共享资源进行读操作或者写操作时，某个线程就有可能获得该共享资源的写锁，进而对共享资源进行写操作。有多少线程请求了写锁以及以何种顺序请求写锁并不重要，除非你想保证写锁请求的公平性。
按照上面的叙述，简单的实现出一个读/写锁，代码如下
**/
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++; //如果没有，读者+1。。之后可以进行读操作
}
//减少读锁，读操作完成后，执行
public synchronized void unlockRead(){
readers--; //读着数减一
notifyAll(); //通知所有监控线程
}
/**
* 获取写锁
**/
public synchronized void lockWrite()
throws InterruptedException{
writeRequests++; //写请求数+1
while(readers > 0 || writers > 0){ //如果有读者活有写者，等待（阻塞）
wait();
}
writeRequests--; //获取写锁后，写等待数-1，写者数+1
writers++;
}
//减少写者
public synchronized void unlockWrite()
throws InterruptedException{
writers--; //写者数-1
notifyAll(); //通知所有监控线程
}
}
/**
ReadWriteLock类中，读锁和写锁各有一个获取锁和释放锁的方法。
读锁的实现在lockRead()中,只要没有线程拥有写锁（writers==0），且没有线程在请求写锁（writeRequests ==0），所有想获得读锁的线程都能成功获取。
写锁的实现在lockWrite()中,当一个线程想获得写锁的时候，首先会把写锁请求数加1（writeRequests++），然后再去判断是否能够真能获得写锁，当没有线程持有读锁（readers==0 ）,且没有线程持有写锁（writers==0）时就能获得写锁。有多少线程在请求写锁并无关系。
需要注意的是，在两个释放锁的方法（unlockRead，unlockWrite）中，都调用了notifyAll方法，而不是notify。要解释这个原因，我们可以想象下面一种情形：
如果有线程在等待获取读锁，同时又有线程在等待获取写锁。如果这时其中一个等待读锁的线程被notify方法唤醒，但因为此时仍有请求写锁的线程存在（writeRequests>0），所以被唤醒的线程会再次进入阻塞状态。然而，等待写锁的线程一个也没被唤醒，就像什么也没发生过一样（译者注：信号丢失现象）。
如果用的是notifyAll方法，所有的线程都会被唤醒，然后判断能否获得其请求的锁。
用notifyAll还有一个好处。如果有多个读线程在等待读锁且没有线程在等待写锁时，调用unlockWrite()后，所有等待读锁的线程都能立马成功获取读锁 —— 而不是一次只允许一个。
**/
//读/写锁的重入
/**
上面实现的读/写锁(ReadWriteLock) 是不可重入的，当一个已经持有写锁的线程再次请求写锁时，就会被阻塞。原因是已经有一个写线程了——就是它自己。此外，考虑下面的例子：
Thread 1 获得了读锁
Thread 2 请求写锁，但因为Thread 1 持有了读锁，所以写锁请求被阻塞。
Thread 1 再想请求一次读锁，但因为Thread 2处于请求写锁的状态，所以想再次获取读锁也会被阻塞。
上面这种情形使用前面的ReadWriteLock就会被锁定——一种类似于死锁的情形。不会再有线程能够成功获取读锁或写锁了。
为了让ReadWriteLock可重入，需要对它做一些改进。下面会分别处理读锁的重入和写锁的重入。
**/
//读锁重入
/**
为了让ReadWriteLock的读锁可重入，我们要先为读锁重入建立规则：
要保证某个线程中的读锁可重入，要么满足获取读锁的条件（没有写或写请求），要么已经持有读锁（不管是否有写请求）。
要确定一个线程是否已经持有读锁，可以用一个map来存储已经持有读锁的线程以及对应线程获取读锁的次数，当需要判断某个线程能否获得读锁时，就利用map中存储的数据进行判断。下面是方法lockRead和unlockRead修改后的的代码：
**/
public class ReadWriteLock{
private Map<Thread, Integer> readingThreads =
new HashMap<Thread, Integer>();
private int writers = 0;
private int writeRequests = 0;
/**
* 获取读锁
**/
public synchronized void lockRead()
throws InterruptedException{
Thread callingThread = Thread.currentThread();
while(! canGrantReadAccess(callingThread)){//如果不允许获得，阻塞当前线程
wait();
}
readingThreads.put(callingThread, //如果允许，或者解除阻塞后允许读访问
(getAccessCount(callingThread) + 1)); //增加读者数
}
/**
* 解除读锁，
* 有读者，数量-1，没有了删除key
* 最后发送通知，所有等待读写的线程，根据策略读写，或者阻塞。
**/
public synchronized void unlockRead(){
Thread callingThread = Thread.currentThread();
int accessCount = getAccessCount(callingThread);
if(accessCount == 1) {
readingThreads.remove(callingThread);
} else {
readingThreads.put(callingThread, (accessCount -1));
}
notifyAll();
}
/***
* 判断是否允许读访问，=======重入的读锁比写锁优先级高！=======
**/
private boolean canGrantReadAccess(Thread callingThread){
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;
}
}
/**
代码中我们可以看到，只有在没有线程拥有写锁的情况下才允许读锁的重入。此外，重入的读锁比写锁优先级高。
写锁重入
仅当一个线程已经持有写锁，才允许写锁重入（再次获得写锁）。下面是方法lockWrite和unlockWrite修改后的的代码。
**/
public class ReadWriteLock{
private Map<Thread, Integer> readingThreads =
new HashMap<Thread, Integer>();
private int writeAccesses = 0;
private int writeRequests = 0;
private Thread writingThread = null;
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{
writeAccesses--;
if(writeAccesses == 0){
writingThread = null;
}
notifyAll();
}
/**
* 判断是否
**/
private boolean canGrantWriteAccess(Thread callingThread){
if(hasReaders()) return false; //有读者，不能写
if(writingThread == null) return true; //没有其他写入线程，可以写
if(!isWriter(callingThread)) return false; //如果写线程不为空，并且当前不是写线程，不可以
return true; //否则（当前写线程重入）：可以
}
private boolean hasReaders(){
return readingThreads.size() > 0;
}
private boolean isWriter(Thread callingThread){
return writingThread == callingThread;
}
}
/**
注意在确定当前线程是否能够获取写锁的时候，是如何处理的。
读锁升级到写锁
有时，我们希望一个拥有读锁的线程，也能获得写锁。想要允许这样的操作，要求这个线程是唯一一个拥有读锁的线程。
writeLock()需要做点改动来达到这个目的：
**/
public class ReadWriteLock{
private Map<Thread, Integer> readingThreads =
new HashMap<Thread, Integer>();
private int writeAccesses = 0;
private int writeRequests = 0;
private Thread writingThread = null;
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{
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 boolean hasReaders(){
return readingThreads.size() > 0;
}
private boolean isWriter(Thread callingThread){
return writingThread == callingThread;
}
/**
* 判断此线程是否是唯一的读者
**/
private boolean isOnlyReader(Thread callingThread){
return readers == 1 && readingThreads.get(callingThread) != null; //只有一个读者，并且就是当前线程
}
}
/**
现在ReadWriteLock类就可以从读锁升级到写锁了。
写锁降级到读锁
有时拥有写锁的线程也希望得到读锁。如果一个线程拥有了写锁，那么自然其它线程是不可能拥有读锁或写锁了。
所以对于一个拥有写锁的线程，再获得读锁，是不会有什么危险的。
我们仅仅需要对上面canGrantReadAccess方法进行简单地修改：
**/
public class ReadWriteLock{
private boolean canGrantReadAccess(Thread callingThread){
if(isWriter(callingThread)) return true; //如果是写线程，可以读
if(writingThread != null) return false; //如果不是写线程，而且有其它写线程，不能读
if(isReader(callingThread) return true; //如果当前线程是读线程，可以重入，能读
if(writeRequests > 0) return false; //如果当前线程不是读线程，如果有其它写等待线程，不能读
return true; //如果当前线程不是读线程，没有其它线程写等待，可读
}
}
/**
可重入的ReadWriteLock的完整实现
下面是完整的ReadWriteLock实现。为了便于代码的阅读与理解，简单对上面的代码做了重构。重构后的代码如下。
**/
public class ReadWriteLock{
private Map<Thread, Integer> readingThreads =
new HashMap<Thread, Integer>();
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(); //注意wait的是当前的ReadWriteLock实例
}
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(); //释放读锁后，通知所有观察当前锁（ReadWriteLock实例）上的线程
}
public synchronized void lockWrite()
throws InterruptedException{
writeRequests++; //写请求计数器+1
Thread callingThread = Thread.currentThread();
while(!canGrantWriteAccess(callingThread)){ //不能写时，循环阻塞
wait();
}
writeRequests--; //获得写锁后，写请求数-1，写访问数+1
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--; //写访问计数器-1
if(writeAccesses == 0){ //如果写访问数为零，设置写线程为空（写访问数>1,一定是重入写了）
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;
}
}
/**
在finally中调用unlock()
在利用ReadWriteLock来保护临界区时，如果临界区可能抛出异常，在finally块中调用readUnlock()和writeUnlock()就显得很重要了。
这样做是为了保证ReadWriteLock能被成功解锁，然后其它线程可以请求到该锁。这里有个例子：
**/
lock.lockWrite();
try{
//do critical section code, which may throw exception
} finally {
lock.unlockWrite();
}
/**
上面这样的代码结构能够保证临界区中抛出异常时ReadWriteLock也会被释放。
如果unlockWrite方法不是在finally块中调用的，当临界区抛出了异常时，ReadWriteLock 会一直保持在写锁定状态，就会导致所有调用lockRead()或lockWrite()的线程一直阻塞。
唯一能够重新解锁ReadWriteLock的因素可能就是ReadWriteLock是可重入的，当抛出异常时，这个线程后续还可以成功获取这把锁，然后执行临界区以及再次调用unlockWrite()，这就会再次释放ReadWriteLock。
但是如果该线程后续不再获取这把锁了呢？所以，在finally中调用unlockWrite对写出健壮代码是很重要的。
**/读写锁实现及讲解
精选 转载shenli9java 博主文章分类：Java多线程、并发
文章标签 读写锁 ReadWriteLock 文章分类 代码人生
提问和评论都可以，用心的回复会被更多人看到
评论
发布评论
相关文章
