本文最后更新于 2023-09-19，文章内容可能已经过时。

8 读写锁

8.1 读写锁介绍

现实中有这样一种场景：对共享资源有读和写的操作，且写操作没有读操作那么频繁。在没有写操作的时候，多个线程同时读一个资源没有任何问题，所以应该允许多个线程同时读取共享资源；但是如果一个线程想去写这些共享资源，就不应该允许其他线程对该资源进行读和写的操作了。

针对这种场景，JAVA 的并发包提供了读写锁 ReentrantReadWriteLock，它表示两个锁，一个是读操作相关的锁，称为共享锁；一个是写相关的锁，称为排他锁

线程进入读锁的前提条件：

没有其他线程的写锁
没有写请求, 或者有写请求，但调用线程和持有锁的线程是同一个(可重入锁)。

线程进入写锁的前提条件：

没有其他线程的读锁
没有其他线程的写锁

而读写锁有以下三个重要的特性：

（1）公平选择性：支持非公平（默认）和公平的锁获取方式，吞吐量还是非公平优于公平。

（2）重进入：读锁和写锁都支持线程重进入。

（3）锁降级：遵循获取写锁、获取读锁再释放写锁的次序，写锁能够降级成为读锁。

8.2 ReentrantReadWriteLock

ReentrantReadWriteLock 类的整体结构

public class ReentrantReadWriteLock implements ReadWriteLock, 
java.io.Serializable {
     /** 读锁 */
     private final ReentrantReadWriteLock.ReadLock readerLock;
     /** 写锁 */
     private final ReentrantReadWriteLock.WriteLock writerLock;
     final Sync sync;

     /** 使用默认（非公平）的排序属性创建一个新的
    ReentrantReadWriteLock */
     public ReentrantReadWriteLock() {
     	this(false);
     }
     /** 使用给定的公平策略创建一个新的 ReentrantReadWriteLock */
     public ReentrantReadWriteLock(boolean fair) {
         sync = fair ? new FairSync() : new NonfairSync();
         readerLock = new ReadLock(this);
         writerLock = new WriteLock(this);
     }
     /** 返回用于写入操作的锁 */
     public ReentrantReadWriteLock.WriteLock writeLock() { return     writerLock; }

     /** 返回用于读取操作的锁 */
     public ReentrantReadWriteLock.ReadLock readLock() { return readerLock; }
    
     abstract static class Sync extends AbstractQueuedSynchronizer {}
     static final class NonfairSync extends Sync {}
     static final class FairSync extends Sync {}
     public static class ReadLock implements Lock, java.io.Serializable {}
     public static class WriteLock implements Lock, java.io.Serializable {}
}

可以看到，ReentrantReadWriteLock 实现了 ReadWriteLock 接口，ReadWriteLock 接口定义了获取读锁和写锁的规范，具体需要实现类去实现；同时其还实现了 Serializable 接口，表示可以进行序列化，在源代码中可以看到 ReentrantReadWriteLock 实现了自己的序列化逻辑。

8.3 入门案例

场景: 使用 ReentrantReadWriteLock 对一个 hashmap 进行读和写操作

8.3.1 实现案例

class Cache {

    private final HashMap<String, Object> map = new HashMap<>();
    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

    public void put(String key, Object value) {

        try {
            System.out.println(Thread.currentThread().getName() + " is writing....");
            TimeUnit.SECONDS.sleep(1);
            map.put(key, value);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    public Object get(String key) {
        try {
            System.out.println(Thread.currentThread().getName() + " is reading....");
            TimeUnit.SECONDS.sleep(1);
            return map.get(key);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

}

public class ReadWriteLockDemo {

    public static void main(String[] args) {
        Cache cache = new Cache();

        for (int i = 1; i <= 5; i++) {
            String num = "num::" + String.valueOf(i);
            new Thread(() -> {
                cache.put(num, num);
            }, "Thread::" + String.valueOf(i)).start();
        }

        for (int i = 1; i <= 5; i++) {
            String num = "num::" + String.valueOf(i);
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " get value : " + cache.get(num));
            }, "Thread::" + String.valueOf(i)).start();
        }
    }
}

此时不加读写锁，发现写的同时读操作也会进行，导致得到了null值。

Thread::2 is writing....
Thread::5 is reading....
Thread::1 is reading....
Thread::3 is reading....
Thread::2 is reading....
Thread::4 is writing....
Thread::5 is writing....
Thread::4 is reading....
Thread::1 is writing....
Thread::3 is writing....
Thread::1 get value : null
Thread::3 get value : null
Thread::5 get value : null
Thread::4 get value : null
Thread::2 get value : num::2

如果此时加读写锁，就能避免如上现象

class Cache {

    private final HashMap<String, Object> map = new HashMap<>();
    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

    public void put(String key, Object value) {
        try {
            rwLock.writeLock().lock();
            System.out.println(Thread.currentThread().getName() + " is writing....");
            TimeUnit.SECONDS.sleep(1);
            map.put(key, value);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            rwLock.writeLock().unlock();
        }
    }

    public Object get(String key) {
        try {
            rwLock.readLock().lock();
            System.out.println(Thread.currentThread().getName() + " is reading....");
            TimeUnit.SECONDS.sleep(1);
            return map.get(key);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            rwLock.readLock().unlock();
        }
    }
}

public class ReadWriteLockDemo {

    public static void main(String[] args) {
        Cache cache = new Cache();

        for (int i = 1; i <= 5; i++) {
            String num = "num::" + String.valueOf(i);
            new Thread(() -> {
                cache.put(num, num);
            }, "Thread::" + String.valueOf(i)).start();
        }

        for (int i = 1; i <= 5; i++) {
            String num = "num::" + String.valueOf(i);
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " get value : " + cache.get(num));
            }, "Thread::" + String.valueOf(i)).start();
        }
    }
}

此时可以看到，加了写锁之后，此时写锁是排他锁，读的线程在写线程没写完前都无法读到，而写完后，读锁是共享锁，如果不加线程睡眠，会同时读出。

Thread::1 is writing....
Thread::2 is writing....
Thread::3 is writing....
Thread::4 is writing....
Thread::5 is writing....
Thread::1 is reading....
Thread::2 is reading....
Thread::3 is reading....
Thread::4 is reading....
Thread::5 is reading....
Thread::1 get value : num::1
Thread::5 get value : num::5
Thread::4 get value : num::4
Thread::3 get value : num::3
Thread::2 get value : num::2

8.4 小结(重要)

在线程持有读锁的情况下，该线程不能取得写锁(因为获取写锁的时候，如果发现当前的读锁被占用，就马上获取失败，不管读锁是不是被当前线程持有)。
在线程持有写锁的情况下，该线程可以继续获取读锁（获取读锁时如果发现写锁被占用，只有写锁没有被当前线程占用的情况才会获取失败）。

原因: 当线程获取读锁的时候，可能有其他线程同时也在持有读锁，因此不能把获取读锁的线程“升级”为写锁；而对于获得写锁的线程，它一定独占了读写锁，因此可以继续让它获取读锁，当它同时获取了写锁和读锁后，还可以先释放写锁继续持有读锁，这样一个写锁就“降级”为了读锁。

JUC基础-8-JUC读写锁