ReentrantReadWriteLock读锁源码分析

Bertha 。 2022-12-21 15:51 146阅读 0赞

读锁的获取，两个核心方法

![20201116225620152.png][]

tryAcquiretry

tryAcquireShared方法
    Thread current = Thread.currentThread();获取当前线程
    int c = getState();获取锁状态 32位
    if (exclusiveCount(c) != 0 && 
        getExclusiveOwnerThread() != current)
        return -1;//写锁次数不是0说明写锁被获取并且不是当前线程获取，那就获取读锁失败！
    int r = sharedCount(c);获取读锁的次数
    if (!readerShouldBlock() && 
        r < MAX_COUNT &&
        compareAndSetState(c, c + SHARED_UNIT)) {
    读锁不被阻塞并且读锁次数小于最大值并且设置读锁次数成功，则说明获取读锁成功。
        if (r == 0) {
            firstReader = current;如果读锁为0，则说明当前线程是第一个获取读锁的，读锁的头节点为当前线程。读锁持有次数为1.
            firstReaderHoldCount = 1;
        } else if (firstReader == current) {
            firstReaderHoldCount++;如果不为0，则说明其他线程获取读锁。判断第一个获取读锁的是否是当前线程，是则把次数累加。
        } 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);

readerShouldBlock方法

获取读锁是否被阻塞，该方法有公平与非公平实现。公平实现

final boolean readerShouldBlock() {
        return hasQueuedPredecessors();//队列是否有前继节点
    }

非公平实现

final boolean readerShouldBlock() {
        return apparentlyFirstQueuedIsExclusive();//队列第一个线程是否持有写锁
    }

fullTryAcquireShared方法

fullTryAcquireShared方法
    
    final int fullTryAcquireShared(Thread current) {
        /*
         * 这段代码与tryAcquireShared中的代码有部分重复，但整体更简单。
         */
        HoldCounter rh = null;
        // 死循环
        for (;;) {
            int c = getState();
            // 如果存在写锁
            if (exclusiveCount(c) != 0) {
                // 并且不是当前线程，获取锁失败，反之，如果持有写锁的是当前线程，那么就会进入下面的逻辑。
                // 反之，如果存在写锁，但持有写锁的是当前线程。那么就继续尝试获取读锁。
                if (getExclusiveOwnerThread() != current)
                    return -1;
            // 如果写锁空闲，且可以获取读锁。
            } else if (readerShouldBlock()) {
                // 第一个读线程是当前线程
                if (firstReader == current) {
                // 如果不是当前线程
                } else {
                    if (rh == null) {
                        rh = cachedHoldCounter;
                        if (rh == null || rh.tid != getThreadId(current)) {
                            // 从 ThreadLocal 中取出计数器
                            rh = readHolds.get();
                            if (rh.count == 0)
                                readHolds.remove();
                        }
                    }
                    if (rh.count == 0)
                        return -1;
                }
            }
            // 如果读锁次数达到 65535 ，抛出异常
            if (sharedCount(c) == MAX_COUNT)
                throw new Error("Maximum lock count exceeded");
            // 尝试对 state 加 65536, 也就是设置读锁，实际就是对高16位加一。
            if (compareAndSetState(c, c + SHARED_UNIT)) {
                // 如果读锁是空闲的
                if (sharedCount(c) == 0) {
                    // 设置第一个读锁
                    firstReader = current;
                    // 计数器为 1
                    firstReaderHoldCount = 1;
                // 如果不是空闲的，查看第一个线程是否是当前线程。
                } else if (firstReader == current) {
                    firstReaderHoldCount++;// 更新计数器
                } else {// 如果不是当前线程
                    if (rh == null)
                        rh = cachedHoldCounter;
                    if (rh == null || rh.tid != getThreadId(current))// 如果最后一个读计数器所属线程不是当前线程。
                        // 自己创建一个。
                        rh = readHolds.get();
                    else if (rh.count == 0)
                        readHolds.set(rh);
                    // 对计数器 ++
                    rh.count++;
                    // 更新缓存计数器。
                    cachedHoldCounter = rh; // cache for release
                }
                return 1;
            }
        }}

doAcquireShared方法

private void doAcquireShared(int arg) {
        final Node node = addWaiter(Node.SHARED);//当前线程入队列
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {//不断尝试获取
                final Node p = node.predecessor();前节点
                if (p == head) {
                    int r = tryAcquireShared(arg);如果前节点是头，则再试一次
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        if (interrupted)
                            selfInterrupt();
                        failed = false;
                        return;
                    }//获取成功了设置节点信息 跳出循环
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }//失败了就去阻塞线程shouldParkAfterFailedAcquire方法就是设置唤醒标识。
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

boolean readerShouldBlock() \{   
    return hasQueuedPredecessors();//队列是否有前继节点  
\}

方法Shared方法tryAcquireShared方法

[20201116225620152.png]: /images/20221120/a789bb36421e4263abf7328b0ac9dc1c.png