ReentrantReadWriteLock实现过程&公平锁和独占锁&锁降级升级

ReentrantReadWriteLock的UML图

独占锁（写）和公平锁（读）

• 写锁：当一个写线程拥有锁后，其他读写线程不能获取锁。
• 读锁：当一个读线程获取锁后，其他读线程仍然可以获取锁，但是写线程不能获取锁。

在 ReentrantReadWriteLock 中，同样使用AQS的state字段来表示锁的状态。那么 ReentrantReadWriteLock 是如何通过这一个字段，来同时记录读锁和写锁的状态呢？

先看UML图里面的Sync类中的2个静态常量值。

static final int SHARED_UNIT= (1 << SHARED_SHIFT);  // 也就是二进制 1000 0000 0000 0000  
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1; // 也就是 0111 1111 1111 1111

在 ReentrantReadWriteLock 中，如果读线程获取到了读锁，则state值就会加一个 SHARED_UNIT 。假设同时有三个读线程获取到了锁，那么这时的state值是 1 1000 0000 0000 0000.

而如果一个写线程获取到了锁，这时候 state 会直接加1。

因此，如果我们想要获取持有写锁持有数量，只要调用下面方法，假设这时候state值是 2，和独占锁掩码与一下，就会忽略 共享锁的持有数量值， 获取独占锁持有数量是2.

static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

如果想要获取到读锁的持有数，则调用下面方法，直接忽略独占锁的持有数值。获取到共享锁的持有数量。

static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }

锁策略

• 公平锁策略：如果当前线程不是同步队列中的第一个节点，则阻塞

• 非公平锁策略：为了防止写线程饥饿，如果同步队列中的第一个节点是写线程，则阻塞当前线程。

锁升级和降级

• 升级：同一个线程中，在没有释放读锁的情况下，就去申请写锁，这属于锁升级，ReentrantReadWriteLock是不支持的。
• 降级：同一个线程中，在没有释放写锁的情况下，就去申请读锁，这属于锁降级，ReentrantReadWriteLock是支持的

锁升级

假设线程1，线程2同时到了执行了rtLock.readLock().lock();这个语句。也就是同时获取到了读锁。

继续往下执行，线程1在获取写锁的时候，由于线程2持有了读锁，因此无法获取到写锁。

同理，线程2由于线程1持有读锁，也获取不到写锁。这时候就会产生死锁。

ReadWriteLock rtLock = new ReentrantReadWriteLock();
rtLock.readLock().lock();
System.out.println("get readLock.");

rtLock.writeLock().lock();    // 可能获取不到写锁
System.out.println("blocking");
rtLock.readLock().unlock();
rtLock.writeLock().unlock();

锁降级

用同样的方式思考降级，就不会发生上面问题。因为线程1在获取到写锁之后，线程2是获取不到写锁的。。

ReadWriteLock rtLock = new ReentrantReadWriteLock();
rtLock.writeLock().lock();
System.out.println("writeLock");

rtLock.readLock().lock();
System.out.println("get read lock");
rtLock.writeLock().unlock();
rtLock.readLock().unlock();

读锁的Lock的基本流程

1. 尝试获取公平锁 tryAcquireShared

   1. 查看锁是否被写线程持有。如果是，则直接获取失败。
   2. 判断读锁是否应该阻塞。readerShouldBlock
      1. 非公平情况：查看等待队列中的下一节点是否是写线程，如果是，则阻塞。
      2. 公平情况：查看当前线程是否位于队头，如果不是，则阻塞。
   3. 尝试设置更新state的值
      如果更新成功，则更新当前线程对应的HoldCounter 的值。记录当前线程获取锁的次数,用来后面的重入。然后直接返回。
   4. 如果没有更新成功，循环不断获取锁。fullTryAcquireShared
      不断重复1.2.3流程，直到获取失败（写线程持有锁），或者获取成功才会退出循环。

2. 加入等待队列，并循环获取锁doAcquireShared

   1. 创建一个共享锁线程节点，并加入等待队列。
   2. 如果前置节点是等待队列的队头，则尝试获取锁。
   3. 当获取到锁之后，进行传播 setHeadAndPropagate。遍历后面的所有节点线程。将所有公平锁线程获取锁。

具体代码的实现

获取公平锁

• 读锁的tryAcquire方法实现

// java.util.concurrent.locks.ReentrantReadWriteLock.Sync#tryAcquireShared
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);
        }

• 如果有写线程阻塞，读线程加入队列。而当队列头部的读线程获取到了读锁的时候，就会执行下面方法。

// java.util.concurrent.locks.AbstractQueuedSynchronizer#setHeadAndPropagate
private void setHeadAndPropagate(Node node, int propagate) {
        Node h = head; // Record old head for check below
        setHead(node);
        
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
            (h = head) == null || h.waitStatus < 0) {
            Node s = node.next;
            if (s == null || s.isShared())
                doReleaseShared();
        }
    }

可以看到，该方法会遍历所有子节点，并执行doReleaseShared方法。

获取写锁

• 写锁的tryAcquire

// java.util.concurrent.locks.ReentrantReadWriteLock.Sync#tryAcquire
protected final boolean tryAcquire(int acquires) {
            Thread current = Thread.currentThread();
            int c = getState();
            int w = exclusiveCount(c);
            if (c != 0) {
                // (Note: if c != 0 and w == 0 then shared count != 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;
        }

可以看到，写线程，获取锁的方式，基本上就是获取独占锁的方式。