ReentrantLock读写锁源码解析

ReentrantLock 流程

读写锁用的是同一个 Sycn 同步器，因此等待队列、state 等也是同一个 , 我们分别以下面的为例 :

t1 -> w.lock t2 -> r.lock

t1 w.lock，t2 r.lock

注意 : ReentrantLock 和 ReentrantReadWriteLock默认都是非公平锁

测试代码

t1 -> w.lock t2 -> r.lock

package cn.knightzz.juc.reentrantlock.readwrite.source;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author 王天赐
 * @title: WriteAndReadLock
 * @projectName hm-juc-codes
 * @description:
 * @website <a href="http://knightzz.cn/">http://knightzz.cn/</a>
 * @github <a href="https://github.com/knightzz1998">https://github.com/knightzz1998</a>
 * @create: 2022-09-21 09:03
 */
@SuppressWarnings("all")
@Slf4j(topic = "c.WriteAndReadLock")
public class WriteAndReadLock {
    static ReentrantReadWriteLock rw = new ReentrantReadWriteLock();
    static ReentrantReadWriteLock.ReadLock readLock = rw.readLock();
    static ReentrantReadWriteLock.WriteLock writeLock = rw.writeLock();

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(() -> {
            log.debug("尝试获取写锁");
            writeLock.lock();
            try {
                log.debug("获取写锁成功, 开始写入数据...");
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                writeLock.unlock();
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            log.debug("尝试获取读锁");
            readLock.lock();
            try {
                log.debug("获取读锁成功, 开始读取数据...");
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                readLock.unlock();
            }
        }, "t2");

        t1.start();
        t2.start();
    }
}

基本流程

[1] t1 成功上锁，流程与 ReentrantLock 加锁相比没有特殊之处，不同是写锁状态占了 state 的低 16 位，而读锁使用的是 state 的高 16 位

[2] t2 执行 readLock.lock()，这时进入读锁的 sync.acquireShared(1) 流程，首先会进入 tryAcquireShared 流程。如果有写锁占据，那么 tryAcquireShared 返回 -1 表示失败

tryAcquireShared 返回值表示 : -1 表示失败 0 表示成功，但后继节点不会继续唤醒 , 正数表示成功，而且数值是还有几个后继节点需要唤醒，读写锁返回 1


// ReentrantReadWriteLock 
public void lock() {
    sync.acquireShared(1);
}

// Sync 继承自 AQS

 public final void acquireShared(int arg) {
        if (tryAcquireShared(arg) < 0)
            doAcquireShared(arg);
  }

// ReentrantReadWriteLock
protected final int tryAcquireShared(int unused) {

            Thread current = Thread.currentThread();
    		// 获取 state
            int c = getState();
    		// 判断前 16位是否是0(读锁是否被持有)
            if (exclusiveCount(c) != 0 &&
                // 判断持有锁的是否是当前线程
                getExclusiveOwnerThread() != current)
                return -1;
    		// 获取后16位状态 (写锁是否被持有)
            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);
        }

[3] 这时会进入 sync.doAcquireShared(1) 流程，首先也是调用 addWaiter 添加节点，不同之处在于节点被设置为 Node.SHARED 模式而非 Node.EXCLUSIVE 模式，注意此时 t2 仍处于活跃状态

[4] t2 会看看自己的节点是不是老二，如果是，还会再次调用 tryAcquireShared(1) 来尝试获取锁

[5] 如果没有成功，在 doAcquireShared 内 for (;;) 循环一次，把前驱节点的 waitStatus 改为 -1，再 for (;;) 循环一次尝试 tryAcquireShared(1) 如果还不成功，那么在parkAndCheckInterrupt() 处 park