Java读写锁

读写锁在同一时刻可以允许多个读线程访问，但是在写线程访问时，所有的读线程和其他写线程均被阻塞。读写锁维护了一对锁，一个读锁和一个写锁，通过分离读锁和写锁，使得并发性相比一般的排它锁有了很大的提升。

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

• 支持非公平和公平的锁获取方式，默认是非公平
• 支持锁的重进入
• 支持锁降级

ReentrantReadWriteLock是对接口ReadWriteLock的实现，ReadWriteLock中仅定义了获取读锁和获取写锁的两个方法，即：

这两个方法皆由ReentrantReadWriteLock类具体实现。通过观察ReentrantReadWriteLock的源码发现，其内部含有ReadLock和WriteLock这两个类，代表ReentrantReadWriteLock拥有的一对读锁和写锁，而这两个类又都是靠一个静态内部类Sync实现的。Sync是继承了AbstractQueuedSynchronizer，用于管理读写锁的同步状态。

读写锁的实现分析

1.读写状态的设计

读写锁依赖于自定义同步器来实现同步功能，其读写状态就是同步器的同步状态。读写锁的自定义同步器需要在同步状态（一个整型变量）上维护多个读线程和一个写线程的状态，所以就需要“按位切割使用”这个整型变量。此处，读写锁将这个整型变量切分为了两个部分，高16位表示读，低16位表示写。划分方式如下图所示：

上图表示的同步状态显示有两个线程已经获取了读锁。读写锁是通过位运算迅速确定读和写各自的状态的，假设当前的同步状态为state，那么读状态和写状态的计算方式如下：

写状态： state & 0x0000ffff     写状态加1：state+1
读状态： state >>> 16			读状态加1：state+(1<<16)

2.写锁的获取与释放

首先看一下写锁的加锁源码：

protected final boolean tryAcquire(int acquires) {
    Thread current = Thread.currentThread();
    int c = getState(); // 获取同步状态
    int w = exclusiveCount(c); // 根据同步状态获取写锁状态
    // 已经有线程获取到了锁
    if (c != 0) {
        // 如果写线程数（w）为0（换言之存在读锁） 或者写锁不为0，同时持有锁的线程不是当前线程就返回失败
        if (w == 0 || current != getExclusiveOwnerThread())
            return false;
        
        // 如果写入锁的数量大于最大数（65535，2的16次方-1）就抛出一个Error。
        if (w + exclusiveCount(acquires) > MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
        
        // 写锁重入
        setState(c + acquires);
        return true;
    }
    
    // 如果当且写线程数为0，并且当前线程需要阻塞那么就返回失败；或者如果通过CAS增加写线程数失败也返回失败。
    if (writerShouldBlock() ||
        !compareAndSetState(c, c + acquires))
        return false;
    
    // 如果c=0，w=0（没有写锁也没有读锁）或者c>0，w>0（重入），则设置当前线程为锁的拥有者
    setExclusiveOwnerThread(current);
    return true;
}

从上面的源码可以看出，写锁是一个支持重进入的排它锁。如果当前线程已经获取到了写锁，那么再次获取时，直接增加写状态。如果当前线程在获取写锁时，读锁已经被获取（读状态不为0）或者该线程不是已经获取写锁的线程，则当前线程进入等待状态。

之所以要判断读锁是否存在，是因为读写锁要确保写锁的操作对读锁可见，如果允许读锁在已被获取的情况下还能允许写锁的获取，那么正在运行的其他线程可能就无所感知当前写线程的操作。

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

3.读锁的获取与释放

下面是读锁的源码：

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);
}

读锁是一个支持重进入的共享锁，他能够被多个线程同时获取，在没有其他写线程访问（写状态为0）时，读锁总是会被成功地获取，而所做的也只是（线程安全地）增加读状态。

可以看到在tryAcquireShared(int unused)方法中，如果其他线程已经获取了写锁，则当前线程获取读锁失败，进入等待状态。

如果当前线程获取了写锁或者写锁未被获取，则当前线程（线程安全，依靠CAS保证）增加读状态（增加的值是1<<16），成功获取读锁。

需要注意的是，读状态是所有线程获取读锁次数的总和，而每个线程各自获取读锁的次数只能选择保存在ThreadLocal中，由线程自身维护。

读锁的每次释放（线程安全的，可能有多个读线程同时释放读锁）均减少读状态，减少的值是“1<<16”。所以读写锁才能实现读读的过程共享，而读写、写读、写写的过程互斥。

4.锁降级

锁降级指的是写锁降级成为读锁。如果当前线程拥有写锁，然后将其释放，最后再获取读锁，这种分段完成的过程不能称之为锁降级。锁降级是指把持住（当前拥有的）写锁，再获取到读锁，随后释放先前拥有的写锁的过程。

ReentrantReadWriteLock不支持锁升级，目的是为了保证数据可见性，如果读锁已被多个线程获取，其中任意线程成功获取了写锁并更新了数据，则其更新对其他获取到读锁的线程是不可见的。

读写锁的使用示例

package concurrent.lock;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.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();
    public static final Object get(String key){

        r.lock();

        try {
            return map.get(key);
        }finally {
            r.unlock();
        }
    }

    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和clear方法中，需要先获取写锁，当获取了写锁之后，其他线程对于数据的读和写操作均会被阻塞，只有在写锁释放以后，其他的读写操作才能继续。

Cache类通过使用读写锁提升了读操作的并发性，也保证了每次写操作对所有的读写操作的可见性，同时还简化了编程方式。

参考：《Java并发编程的艺术》
https://tech.meituan.com/2018/11/15/java-lock.html