ReentrantReadWriteLock可重入读写锁的源码解析

ReentrantReadWriteLock 源码解析，欢迎指正。

　　读写锁同样依赖AQS抽象队列同步器来实现同步功能，而读写状态就是其同步器的同步状态。回想ReentrantLock中自定义同步器的实现，同步状态表示锁被一个线程重复获取的次数，

而读写锁的自定义同步器需要在同步状态（一个整形变量）上维护多个读线程和一个写线程的状态，使得该状态的设计成为读写锁实现的关键。

　　如果在一个整形变量上维护多种状态，就一定需要“按位切割使用”这个变量，读写锁讲变量切割分成了两部分，高16位表示读，低16位表示写。

假设当前同步状态值为c ，写状态等于 c & 0x0000FFFF (将高16位全部抹去)，读状态等于c >>>16 (无符号补0右移16位)。

当写状态增加1时，等于c+1 ,当读状态增加1时，等于 c + (1<<<16) ，也就是c + 0x00010000 . 

　　根据状态的划分能得出一个推论：c不等于0时，当写状态 c & 0x0000FFFF 等于0 ，则读状态  c >>>16 大于0 ，即 读锁已被获取。此时，不能获取写锁。

主要分析一下几个方法

package com.study.authority;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @Description:
 * @Auther: BacHe
 * @Date: 2019/9/17 10:59
 */
public  class myTest2 {


    public static void main(String[] args)  {
        //新建读写锁
        ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        //写锁
        ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
        //读锁
        ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();

        //获取写锁
        writeLock.lock();
        //尝试 获取写锁
        writeLock.tryLock();

        //获取读锁
        readLock.lock();
        //尝试 获取读锁
        readLock.tryLock();

        //释放写锁
        writeLock.unlock();
        //释放读锁
        readLock.unlock();

    }

}

 

1.读写状态的设计。第252行。

    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 6317671515068378041L;


//把锁状态变量state按位切割使用。
//高16位表示读，低16位表示写。
        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;

//变量c 是当前锁的同步状态值。
//读状态等于c>>>16 ,无符号补0右边移16位
        static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
//写状态等于c & 0x0000FFFF ,将高16位全部抹去
        static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

 

2.尝试获取写锁。第555行。

       final boolean tryWriteLock() {
 //获取当前线程
            Thread current = Thread.currentThread();
//获取当前状态state锁标志变量
            int c = getState();
            if (c != 0) {
  //获取写锁的次数。返回count中表示的独占保留的数量  
                int w = exclusiveCount(c);
//写锁次数w为0，说明当前有读锁占用。
//当前线程不是获得写锁的线程。
                if (w == 0 || current != getExclusiveOwnerThread())
                    return false;
//写锁次数达到最大次数。因为只能使用16位，所以做了最大次数限制。
                if (w == MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
            }
//CAS修改当前锁标志，写锁状态+1
            if (!compareAndSetState(c, c + 1))
                return false;
//设置当前线程，为得到写锁的线程。
            setExclusiveOwnerThread(current);
            return true;
        }        

 3.尝试获取读锁。第576行。

 final boolean tryReadLock() {
//获取当前线程
            Thread current = Thread.currentThread();
//死循环
            for (;;) {
//获取当前锁标志
                int c = getState();
//写锁次数不为0 并且 写锁线程不是当前线程。
                if (exclusiveCount(c) != 0 &&
                    getExclusiveOwnerThread() != current)
//返回尝试获取读锁失败
                    return false;
//获取读锁被获取的次数
                int r = sharedCount(c);
//达到最大次数 65535 要抛异常
                if (r == MAX_COUNT)
                    throw new Error("Maximum lock count exceeded");
//CAS修改让读标志加1，也就是高16位加1，也就是c加2的16次方。
                if (compareAndSetState(c, c + SHARED_UNIT)) {
                    if (r == 0) {
//读锁没有被获取过，则设置当前线程为第一个得到读锁的线程
                        firstReader = current;
//第一个得到读锁的线程，设置获取到读锁的次数为1
                        firstReaderHoldCount = 1;
//如果当前线程是第一个得到读锁的线程
                    } else if (firstReader == current) {
//第一个得到读锁的线程，设置获取到读锁的次数加1
                        firstReaderHoldCount++;
                    } else {
//缓存的获取读锁次数的计数器
                        HoldCounter rh = cachedHoldCounter;
//如果计数器为空，或者 计数器的线程id不是当前线程的id
                        if (rh == null || rh.tid != getThreadId(current))
//从ThreadLocal获取当前线程的持有计数器（继承ThreadLocal，重写initialValue方法，新建计数器new HoldCounter()返回）
                            cachedHoldCounter = rh = readHolds.get();
                        else if (rh.count == 0)
//把持有计数器设置给本地线程
                            readHolds.set(rh);
//持有计数器数量加1
                        rh.count++;
                    }
//返回获取读锁成功
                    return true;
                }
            }
        }

 

转载于:https://www.cnblogs.com/itbac/p/11550710.html