Java 读写锁

引言

关于CopyOnWrite容器的，但是它也有一些缺点：

  • 内存占用问题：因为CopyOnWrite的写时复制机制每次进行写操作的时候都会有两个数组对象的内存，如果这个数组对象占用的内存较大的话，如果频繁的进行写入就会造成频繁的Yong GC和Full GC

  • 数据一致性问题：CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。读操作的线程可能不会立即读取到新修改的数据，因为修改操作发生在副本上。但最终修改操作会完成并更新容器所以这是最终一致性。当时有说到解决这两个缺点可以使用Collections.synchronizedList()来替代，找个无非就是对list的增删改查方法都加了synchronized实现。synchronized其实是一个独占锁 （排他锁）。但是这样的话就会存在一个性能问题，如果对于读多写少的场景，每次读也要去获取锁，读完了之后再释放锁，这样就造成了每个读的请求都要进行获取锁，但是读的话并不会引起数据不安全，这样就会造成一个性能瓶颈。为了解决这个问题，就又出现了一种新的锁，读写锁(ReadWriteLock)。

    什么是读写锁

    根据名字也可以猜个大概，就是有两把锁，分别是读锁和写锁。读锁在同一时刻可以允许多个读线程获取，但是在写线程访问的时候，所有的读线程和其他写线程都会被阻塞。写锁同一时刻只能有一个写线程获取成功，其他都会被阻塞。读写锁实际维护了两把锁，一个读锁和一个写锁，通过读锁和写锁进行区分，在读多写少的情况下并发性比独占锁有了很大的提升。在java里面对读写锁的实现就是ReentrantReadWriteLock，它有以下特性：

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

  • 重入性：支持重入，读锁获取后能再次获取，写锁获取之后能够再次获取写锁，同时也能够获取读锁；

  • 锁降级：遵循获取写锁，获取读锁再释放写锁的次序，写锁能够降级成为读锁

    ReentrantReadWriteLock 的使用

    先从官网来个事例https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/ReentrantReadWriteLock.html，看看它是如何使用的

    1. class RWDictionary {
    2.   private final Map<String, Data> m = new TreeMap<String, Data>();
    3.   private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    4.   private final Lock r = rwl.readLock();
    5.   private final Lock w = rwl.writeLock();
    7.   public Data get(String key) {
    8.       r.lock();
    9.       try { return m.get(key); }
    10.       finally { r.unlock(); }
    11.   }
    12.   public String[] allKeys() {
    13.       r.lock();
    14.       try { return m.keySet().toArray(); }
    15.       finally { r.unlock(); }
    16.   }
    17.   public Data put(String key, Data value) {
    18.       w.lock();
    19.       try { return m.put(key, value); }
    20.       finally { w.unlock(); }
    21.   }
    22.   public void clear() {
    23.       w.lock();
    24.       try { m.clear(); }
    25.       finally { w.unlock(); }
    26.   }
    27. }

    这个使用起来还是非常简单明了的，跟ReentrantLock的用法基本一致，写的时候获取写锁，写完了释放写锁，读的时候获取读锁，读完了就释放读写。

    读写锁的实现分析

    ReentrantLock是通过state来控制锁的状态，以及通过state来进行实现的那ReentrantReadWriteLock毋庸置疑肯定也是通过AQS的state来实现的，不过state是一个int值它是如何来读锁和写锁的。

    读写锁状态的实现分析

    如果有看过线程池的源码，线程池的状态和线程数是通过一个int类型原子变量（高3位保存运行状态，低29位保存线程数）来控制的。同样的ReentrantReadWriteLock也是通过一个state的高16位和低16位来分别控制读的状态和写状态。
    2021-06-19-12-09-08-078376.png
    下面就来看看它是如何通过一个字段来实现读写分离的, ```java static final int SHARED_SHIFT = 16; static final int SHARED_UNIT = (1 << SHARED_SHIFT); static final int MAX_COUNT = (1 << SHARED_SHIFT) - 1; static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;

/ Returns the number of shared holds represented in count */ static int sharedCount(int c) { return c >>> SHARED_SHIFT; } / Returns the number of exclusive holds represented in count */ static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

  2. - `sharedCount`：读锁数量 是将同步状态（int c）无符号右移16位，即取同步状态的高16位。
  3. - `exclusiveCount`：写锁数量 要看下`EXCLUSIVE_MASK` 这个静态变量：它是1进行左移16位然后减1也就是`0X0000FFFF`即 `(1 << SHARED_SHIFT) - 1= 0X0000FFFF` 所以`exclusiveCount `就是相当于 `c&0X0000FFFF` 所以也就是低16位用来表示写锁的获取次数。
  4. <a name="KzUjj"></a>
  5. ## 源码分析
  6. 基于jdk1.8 既然`ReentrantReadWriteLock`也是基于`AQS`来实现的，那么它肯定是重写了AQS的获取锁的方法，那就直接去`ReentrantReadWriteLock`这个类里面看看`lock`的地方先看看获取读锁的地方
  7. ```java
  8. protected final boolean tryAcquire(int acquires) {
  9.     /*
  10.      * Walkthrough:
  11.      * 1. If read count nonzero or write count nonzero
  12.      *    and owner is a different thread, fail.
  13.      * 2. If count would saturate, fail. (This can only
  14.      *    happen if count is already nonzero.)
  15.      * 3. Otherwise, this thread is eligible for lock if
  16.      *    it is either a reentrant acquire or
  17.      *    queue policy allows it. If so, update state
  18.      *    and set owner.
  19.      */
  20.     Thread current = Thread.currentThread();
  21.     // 获取写锁当前的同步状态
  22.     int c = getState();
  23.     // 写锁次数
  24.     int w = exclusiveCount(c);
  25.     if (c != 0) {
  26.         // (Note: if c != 0 and w == 0 then shared count != 0)
  27.         // 当前状态不为0，但是写锁为0 就说明读锁不为0
  28.         // 当读锁已被读线程获取或者当前线程不是已经获取写锁的线程的话获取写锁失败
  29.         if (w == 0 || current != getExclusiveOwnerThread())
  30.             return false;
  31.         if (w + exclusiveCount(acquires) > MAX_COUNT)
  32.             throw new Error("Maximum lock count exceeded");
  33.         // Reentrant acquire 获取到写锁
  34.         setState(c + acquires);
  35.         return true;
  36.     }
  37.     //writerShouldBlock 公平锁和非公平锁的判断
  38.     if (writerShouldBlock() ||
  39.         !compareAndSetState(c, c + acquires))
  40.         return false;
  41.     setExclusiveOwnerThread(current);
  42.     return true;
  43. }

写锁完了，接下来肯定就是读锁了由于读锁是共享锁，所以也应该重写了tryAcquireShared 这个就不贴代码了，和读锁差不多这个就不做分析了。其实把AQS弄明白了再来看这些基于AQS来实现的玩意还是比较容易的。

读写锁的升级与降级

前面有提到读写锁是可以降级的，但是没有说是否可以升级。先看看什么是锁降级和锁升级

  • 锁降级：从写锁变成读锁；它的过程是先持有写锁，在获取读锁，再释放写锁。如果是持有写锁，释放写锁，再获取读锁这种情况不是锁降级。

读写锁 - 图2

  • 为什么要锁降级？ :::info 主要是为了保证数据的可见性，如果当前线程不获取读锁而是直接释放写锁， 假设此刻另一个线程（记作线程T）获取了写锁并修改了数据，那么当前线程无法感知线程T的数据更新。如果当前线程获取读锁，即遵循锁降级的步骤，则线程T将会被阻塞，直到当前线程使用数据并释放读锁之后，线程T才能获取写锁进行数据更新。 :::

  • 锁升级：从读锁变成写锁。先持有读锁，再去获取写锁（这是不会成功的）因为获取写锁是独占锁，如果有读锁被占用了，写锁就会放入队列中等待，直至读锁全部被释放之后才有可能获取到写锁。