读写锁（ReentrantReadWriteLock）的实现
读写锁
读写锁在同一时刻允许多个读线程访问，其他写线程阻塞；在写线程访问时，所有的读线程和其他写线程都被阻塞。
读写锁维护了一对锁，一个读锁，一个写锁，通过分离读锁和写锁，使得并发性比一般的排它锁（独占锁）有了很大提升。Java提供的读写锁是ReentrantReadWriteLock。
ReentrantReadWriteLock的特性
| 特性 | 说明 |
|---|---|
| 公平性选择 | 支持非公平(默认)和公平的锁获取方式,吞吐量方面非公平优于公平 |
| 重进入 | 该锁支持重进入,以读写线程为例: 读线程在获取了读锁之后,能够再次获取读锁。 而写线程在获取了写锁之后能够再次获取写锁,同时也可以获取读锁 |
| 锁降级 | 遵循获取写锁、获取读锁再释放写锁的次序,写锁能够降级成为读锁 |
读写锁的接口与示例
ReentrantReadWriteLock实现了ReadWriteLock接口，该接口只有两个方法
- Lock readLock();
- Lock writeLock();
除了接口方法，ReentrantReadWriteLock还提供了便于外界监控内部工作状态的方法：
读写锁使用示例：
public class TestReadWriteLock {
private static Map<String,Object> map = new HashMap<String,Object>();
private static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
private static Lock r = rwl.readLock();
private static Lock w = rwl.writeLock();
// 对于元素获取，使用读锁，允许多个线程并发读
public static final Object get(String key){
w.lock();
try {
return map.get(key);
}finally{
w.unlock();
}
}
// 元素修改使用写锁，其他线程阻塞
public static final Object put(String key,Object value){
r.lock();
try{
return map.put(key,value);
}finally{
r.unlock();
}
}
// 元素修改使用写锁，其他线程阻塞
public static final void clear(){
r.lock();
try{
map.clear();
}finally{
r.unlock();
}
}
}
读写锁的实现
1.读写状态设计
读写锁同样依赖AQS实现，它的读写状态就是基于AQS的同步状态实现的。读写锁将同步状态切分为两部分：高16位表示读状态，低16位表示写状态
读写锁通过位运算来快速定位读和写各自的状态：假设当前同步状态的值为c，写状态就为c&0x0000FFFF，读状态为c >>> 16（无符号位补0右移16位）。当写状态增加1状态变为c+1，当读状态增加1时，状态编码就是c+（1 <<< 16）
2.写锁的获取与释放
1).获取
写锁是一个支持重进入的排它锁。
- 如果当前线程已经获取了写锁，则增加写状态。
- 如果当前线程获取写锁时，读锁已经被获取，或者该线程不是已经获取写锁的线程，则当前线程进入等待状态
protected final boolean tryAcquire(int acquires) {
Thread current = Thread.currentThread();
int c = getState();
// 获取读锁状态
int w = exclusiveCount(c);
if (c != 0) {
// 如果读锁不为零或当前线程没有获取读锁
if (w == 0 || current != getExclusiveOwnerThread())
return false;
if (w + exclusiveCount(acquires) > MAX_COUNT)
throw new Error("Maximum lock count exceeded");
// Reentrant acquire
setState(c + acquires);
return true;
}
if (writerShouldBlock() ||
!compareAndSetState(c, c + acquires))
return false;
setExclusiveOwnerThread(current);
return true;
}
该方法在判断中判断了重入以及读锁是否存在，如果当前线程没有持有写锁（不是重入）或者存在读锁（读状态不为0）那么获取失败。
因为读写锁要确保写锁的操作对读锁可见，如果允许读锁在已被获取的情况下获取写锁，那么正在运行的读锁就无法感知到写锁的操作，所以才会判断是否存在读锁
2).释放
写锁的释放与ReentrantLock的过程类似，每次减少写状态，状态为0表示锁被释放。
3.读锁的获取与释放
1).获取
读锁是一个支持重进入的共享锁，能被多个线程同时获取。
- 在没有写锁被获取的时候，读锁总能被成功获取。
- 如果当前线程获取读锁时，已经有写锁被获取，则当前线程进入等待状态。
- 如果当前线程已经获取了读锁，则增加读状态。
读状态是所有线程获取的总次数，而每个线程各自获取的次数则保存在ThreadLocal中由线程自身维护。可以通过getReadHoleCount()方法获取当前线程获取读锁的次数。
protected final int tryAcquireShared(int unused) {
Thread current = Thread.currentThread();
int c = getState();
// 存在写锁且不是被当前线程获取的，获取失败
if (exclusiveCount(c) != 0 &&
getExclusiveOwnerThread() != current)
return -1;
int r = sharedCount(c);
if (!readerShouldBlock() &&
r < MAX_COUNT &&
compareAndSetState(c, c + SHARED_UNIT)) {
if (r == 0) {
firstReader = current;
firstReaderHoldCount = 1;
} else if (firstReader == current) {
firstReaderHoldCount++;
} else {
HoldCounter rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current))
cachedHoldCounter = rh = readHolds.get();
else if (rh.count == 0)
readHolds.set(rh);
rh.count++;
}
return 1;
}
return fullTryAcquireShared(current);
}
代码主要逻辑：
- 如果其他线程获取了写锁，那么读锁获取失败
- 如果当前没有写锁被获取或者是当前线程获取了写锁，读锁获取成功
2).释放
释放时每次减少读状态，减少的值为1<<16，状态为0表示锁被释放。
因为读锁的获取和释放都是允许多线程操作的，所以需要CAS来保证线程安全。
4.锁降级
锁降级是指持住（当前拥有的）写锁，再获取到读锁，随后释放（先前拥有的）写锁的过程。
读写锁并不支持锁升级，目的是为了保证数据可见性：如果读锁已被多个线程获取，其中任意线程成功获取了写锁并更新了数据，则其他获取了读锁的线程对修改了的数据是不可见的。
关于锁降级的一篇博客推荐：并发编程之——读锁源码分析(解释关于锁降级的争议)