读写锁

读写锁维护了一对锁，一个读锁和一个写锁，通过分离读锁和写锁，使得并发性相比一般的排他锁有了很大提升 

一般情况下，读写锁的性能都会比排它锁好，因为大多数场景读是多于写的。在读多于写的情况下，读写锁能够提供比排它锁更好的并发性和吞吐量。Java并发包提供读写锁的实现是ReentrantReadWriteLock，它提供的特性如表所示。 

读写锁的接口与示例

ReadWriteLock仅定义了获取读锁和写锁的两个方法，即readLock()方法和writeLock()方法，而其实现——ReentrantReadWriteLock，除了接口方法之外，还提供了一些便于外界监控其内部工作状态的方法，这些方法以及描述如表所示 

一个说明读写锁的使用方式的缓存示例：

public class Cache {
　　static Map<String, Object> map = new HashMap<String, Object>();
　　static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
　　static Lock r = rwl.readLock();
　　static Lock w = rwl.writeLock();
　　// 获取一个key对应的value
　　public static final Object get(String key) {
　　　　r.lock();
　　　　try {
　　　　　　return map.get(key);
　　　　} finally {
　　　　　　r.unlock();
　　　　}
　　}
　　// 设置key对应的value，并返回旧的value
　　public static final Object put(String key, Object value) {
　　　　w.lock();
　　　　try {
　　　　　　return map.put(key, value);
　　　　} finally {
　　　　　　w.unlock();
　　　　}
　　}
　　// 清空所有的内容
　　public static final void clear() {
　　　　w.lock();
　　　　try {
　　　　　　map.clear();
　　　　} finally {
　　　　　　w.unlock();
　　　　}
　　}
}

 上述示例中，Cache组合一个非线程安全的HashMap作为缓存的实现，同时使用读写锁的读锁和写锁来保证Cache是线程安全的。在读操作get(String key)方法中，需要获取读锁，这使得并发访问该方法时不会被阻塞。写操作put(String key,Object value)方法和clear()方法，在更新HashMap时必须提前获取写锁，当获取写锁后，其他线程对于读锁和写锁的获取均被阻塞，而只有写锁被释放之后，其他读写操作才能继续。Cache使用读写锁提升读操作的并发性，也保证每次写操作对所有的读写操作的可见性，同时简化了编程方式。 

读写锁的实现分析 （以下没有特别说明读写锁均可认为是ReentrantReadWriteLock ）：

1. 读写状态的设计
2. 写锁的获取与释放
3. 读锁的获取与释放
4. 锁降级

1.读写状态的设计

读写锁同样依赖自定义同步器来实现同步功能，而读写状态就是其同步器的同步状态。回想ReentrantLock中自定义同步器的实现，同步状态表示锁被一个线程重复获取的次数，而读写锁的自定义同步器需要在同步状态（一个整型变量）上维护多个读线程和一个写线程的状态，使得该状态的设计成为读写锁实现的关键。

 如果在一个整型变量上维护多种状态，就一定需要“按位切割使用”这个变量，读写锁将变量切分成了两个部分，高16位表示读，低16位表示写，划分方式如图5-8所示。
 

当前同步状态表示一个线程已经获取了写锁，且重进入了两次，同时也连续获取了两次读锁。 读写锁是通过位运算来确定读和写各自的状态。假设当前同步状态值为S，写状态等于S&0x0000FFFF（将高16位全部抹去），读状态等于S>>>16（无符号右移16位）。当写状态增加1时，等于S+1，当读状态增加1时，等于S+(1<<16)，也就是S+0x00010000。


 2.写锁的获取与释放 

写锁是一个支持重进入的排它锁。如果当前线程已经获取了写锁，则增加写状态。

//ReentrantReadWriteLock的tryAcquire方法
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");
　　　　setState(c + acquires);
　　　　return true;
　　}
　　if (writerShouldBlock() || !compareAndSetState(c, c + acquires)) {
　　　　return false;
　　}
　　setExclusiveOwnerThread(current);
　　return true;
}

 该方法除了重入条件（当前线程为获取了写锁的线程）之外，增加了一个读锁是否存在的判断。 

写锁的释放与ReentrantLock的释放过程基本类似，每次释放均减少写状态，当写状态为0时表示写锁已被释放，从而等待的读写线程能够继续访问读写锁，同时前次写线程的修改对后续读写线程可见。

3.读锁的获取与释放