ReentrantReadWriteLock读写锁

目录

一、前言

1、读写锁

2、可重入锁：

3、公平锁和非公平锁

二、接口

三、实现分析

3.1 读写状态的设计

3.1.1读位运算

3.1.2写位运算

3.2 写锁的获取与释放

3.2.1 tryAcquire方法

3.2.2 tryRelease方法

3.3 读锁的获取与释放

3.3.1 tryAcquireShared方法

3.3.2 tryReleaseShared

4、公平锁和非公平锁

4.1 使用原理

4.2 公平锁

4.3 非公平锁

---

一、前言

ReentrantReadWriteLock中包含三种锁：读写锁、可重入锁、公平/非公平锁

1、读写锁

2、可重入锁：

        又名递归锁，是指在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。说的有点抽象，下面会有一个代码的示例。

• 对于Java ReetrantLock而言，从名字就可以看出是一个重入锁，其名字是Re entrant Lock 重新进入锁。
• 对于Synchronized而言，也是一个可重入锁。可重入锁的一个好处是可一定程度避免死锁。

synchronized void setA() throws Exception{
　　Thread.sleep(1000);
　　setB();
}
 
synchronized void setB() throws Exception{
　　Thread.sleep(1000);
}

3、公平锁和非公平锁

• 公平锁是指多个线程按照申请锁的顺序来获取锁。
• 非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。有可能，会造成优先级反转或者饥饿现象。

        对于Java ReetrantLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。　

　对于Synchronized而言，也是一种非公平锁。由于其并不像ReentrantLock是通过AQS的来实现线程调度，所以并没有任何办法使其变成公平锁。

二、接口

        ReadWriteLock仅定义了获取读锁和写锁的两个方法，即ReadLock()方法和writeLock()方法，而其实现：ReentranReadWriteLock，除接口方法之外，还提供了一些便于外界监控其内部工作状态的方法：

三、实现分析

        分析ReentranReadWriteLock的实现，主要包括读写状态的设计、写锁的获取与释放、读锁的获取与释放以及锁降级。

3.1 读写状态的设计

        ReentranReadWriteLock中使用一个int state变量来维护读锁和写锁的状态。int类型为4字节32位，用state的高16位来存储读锁的状态，用低16位来存储写锁的状态。

3.1.1读位运算

位运算代码

//偏移位数
static final int SHARED_SHIFT = 16;
//读锁计数基本单位
static final int SHARED_UNIT = (1 << SHARED_SHIFT);
//读锁、写锁可重入最大数量
static final int MAX_COUNT = (1 << SHARED_SHIFT) - 1;
//获取低16位的条件
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
 
//获取读锁重入数
static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
//获取写锁重入数
static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

        因为ReentranReadWriteLock中的int整型变量state要同时维护读锁、写锁两种状态，所以ReentranReadWriteLock的是通过高低位切割来实现。

 int占4个字节，一个字节8个比特位，一共2位，切割一下，高16位表示读，底16位表示写。

读位运算

//偏移位数
static final int SHARED_SHIFT = 16;
//读锁计数基本单位
static final int SHARED_UNIT = (1 << SHARED_SHIFT);

读锁使用高16位，每次获取读锁成功+1，所以读锁计数基本单位是1的高16位，即1左移16位（1 << 16）。

 1左移16位等于65536，每次获取读锁成功都会加上65536，通过以下代码将65536右移16位，实际上每次获取读锁还是只是会加1，就好比你早上去上班去公司，晚上下班回家，最终晚上你还是回家了，左移，右移也是这个道理，是一个过程，最终的状态没变。

//偏移位数
static final int SHARED_SHIFT = 16;
//获取读锁重入数
static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }

上面shareCount函数通过位运算是做无符号右移16位获取读锁的重入数，为什么可以获取到呢？

 1左移16位为65536,65536再右移16位为1。

3的二进制

0000 0000 0000 0000 0000 0000 0000 0011

3右移16位

0000 0000 0000 0011 0000 0000 0000 0000

        比如我们获取到了3次读锁，就是65536 * 3 = 196608，转换下公式就是3左移16位等于196608，196608右移16位等于3。

 

虽然我们每次获取到读锁都会+65536，但是获取读锁时会做右移16位，所以效果和+1是一样。

3.1.2写位运算

//偏移位数
static final int SHARED_SHIFT = 16;
//获取低16位的条件
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
//获取写锁重入数
static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

剩下的写锁就非常简单，获取低16位不用左右移动，只要把高16位全部补0即可。

         反推一下，因为不需要左右移动，其实就和正常的数字一样，只不过因为高16位补0，导致数值范围在0~65535，也就是说写锁获取成功直接+1就好了。

         EXCLUSIVE_MASK变量，1右移16位后-1，得到65535，65535的二进制就是111111111111111。

现在来看exclusiveCount函数，该函数内做了位运算&，&又称"与"运算。

"与"运算是两个二进制，每位数运算，运算规则如下

0&0=0
0&1=0
1&0=0
1&1=1

如果相对应位都是1，则结果为1，否则为0

可能有些读者大大还是不太明白，下面放张图16位二进制"与"运算图

         我们发现"与"运算时，只要有一方为0，那结果一定是0，所以为了切割低16位，可以使用&来完成。

 

        从上图可以看出，EXCLUSIVE_MASK高16位都是0，低16位都是1，和它&的变量，高16位全部会变成0，低16位全部保留下来，最终达到获取低16位效果。

c & EXCLUSIVE_MASK，假设c是1，&的过程如下图

 这样看可能没太大感觉，我们把数值调大点，假设c是65536和65537，&的过程如下图

现在有感觉了吧，c的高16位都会变成0，低16位会原样保留，最终达到获取低16位效果。

  EXCLUSIVE_MASK范围在0~65535，所以c的范围也不会超过0~65535，因为超过了也会通过& EXCLUSIVE_MASK回到0~65535。

3.2 写锁的获取与释放

        ReentranReadWriteLock的写锁的获取与释放实现基于同步器AbstractQueuedSynchronizer，与其它独占锁的差异就在于对同步器中tryAcquire()和tryRelease()的重写上，所以下面仅讨论这两个方法。AbstractQueuedSynchronizer独占锁释放获取实现见：AbstractQueuedSynchronizer独占式同步状态获取与释放。

3.2.1 tryAcquire方法

官方给出的注释如下：

1. 若读锁数或写锁数非空，并且当前线程不是读锁或写锁的持有者，获取失败。
2. 若当前线程获取写锁的数量已经达到最大值，失败。
3. 否则，当前线程获得锁。

        protected final boolean tryAcquire(int acquires) {
                /*
             * Walkthrough:
             * 1. 若读锁数或写锁数非空，并且当前线程不是读锁或写锁的持有者，获取失败。
             * 2. 若当前线程获取写锁的数量已经达到最大值，失败。
             * 3. 否则，当前线程获得锁
             */
            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;
        }

3.2.2 tryRelease方法

释放方法很简单，就是对锁的状态进行判断，无误则对状态进行修改。

        protected final boolean tryRelease(int releases) {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            int nextc = getState() - releases;
            boolean free = exclusiveCount(nextc) == 0;
            if (free)
                setExclusiveOwnerThread(null);
            setState(nextc);
            return free;
        }

isHeldExclusively()方法

读锁是否被当前线程持有

        protected final boolean isHeldExclusively() {
            // While we must in general read state before owner,
            // we don't need to do so to check if current thread is owner
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

getExclusiveOwnerThread()方法

获取锁持有者线程

    protected final Thread getExclusiveOwnerThread() {
        return exclusiveOwnerThread;
    }

3.3 读锁的获取与释放

        读锁是一个支持重进入的共享锁，他能够被多个线程同时获取，在没有其他写线程访问（或者写状态为0）时，读锁总会被成功的获取，而所做的也只是（线程安全的）增加读状态。如果当前线程已经获取了读锁，则增加读状态。如果当前线程在获取读锁时，写锁已被其他线程获取，则进入等待状态。

3.3.1 tryAcquireShared方法

        当写锁被另外一个线程持有时，获取读锁失败；否则调用readerShouldBlock()来判断这次获取读锁的操作应不应该阻塞，然后判断读锁数是否达到上限，如果上面两次判断都通过，就调用compareAndSetState()来更新锁状态。

        readerShouldBlock()方法主要是为了避免尝试获取写锁的线程陷入无限阻塞，如果队列的头结点是一个等待的writer节点，那么该方法就会返回true。

        通过下面代码可以看到，在调用compareAndSetState()更新锁状态成功后，会进入if方法体。这段代码的作用主要是：更新第一个获取读锁的线程指针和获取次数（firstReader 和firstReaderHoldCount），更新上一个获取读锁的线程指针（cachedHoldCounter），最后更新当前线程获取读锁的数量（通过ThreadLocal存在自己线程的容器中）。若读锁数量为0，表示当前线程是第一个，执行下面1处代码；若当前线程是第一个，然后现在再次获取了，执行下面2处代码；否则更新当前线程的获取读锁数和cachedHoldCounter，最后获取读锁数都+1。最后返回1。

        protected final int tryAcquireShared(int unused) {
            /*
             * Walkthrough:
             * 1. 如果写锁被另一个线程持有，则获取读锁失败。
             * 2. 否则调用readerShouldBlock()来判断这次获取读锁的操作
             *    应不应该阻塞，然后判断读锁数是否达到上限。
             * 3. 如果上面两次判断都通过，就调用compareAndSetState()来更新锁状态。
             */
            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)) { // 读锁+1
                if (r == 0) {
                    firstReader = current; 
                    //1、当前线程是第一个获取读锁的线程
                    firstReaderHoldCount = 1;
                } else if (firstReader == current) {
                    //2、当前线程是第一个，然后现在再次获取了
                    firstReaderHoldCount++;
                } else {
                    //3、更新当前线程的获取读锁数，然后更新cachedHoldCounter
                    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.3.2 tryReleaseShared

        首先更新firstReader，然后更新cachedHoldCounter和当前线程的锁数量，最后更新锁的状态。同时若读写锁数量都为0，则返回true，这是为了上层方法唤醒阻塞的writer线程；否则返回false。

     protected final boolean tryReleaseShared(int unused) {
            Thread current = Thread.currentThread();//获取当前线程
            if (firstReader == current) {
                // 当前线程是第一个获取读锁的线程
                if (firstReaderHoldCount == 1)
                    firstReader = null;
                else
                    firstReaderHoldCount--;
            } else {
                HoldCounter rh = cachedHoldCounter;    // 上一个获取读锁的线程
                if (rh == null || rh.tid != getThreadId(current))
                    rh = readHolds.get();        // rh指向当前线程获取读锁的数量对象
                int count = rh.count;            // 当前线程获取读锁的数量
                if (count <= 1) {
                    readHolds.remove();
                    if (count <= 0)
                        throw unmatchedUnlockException();
                }
                --rh.count;        // 若当前线程读锁数>1，则数量-1
            }
            for (;;) {
                int c = getState();
                int nextc = c - SHARED_UNIT;         // 读写锁的数量   
                if (compareAndSetState(c, nextc))    // 更新锁状态
                    // 若读写锁数量都为0，则返回true，这里是为了唤醒阻塞的writer线程
                    return nextc == 0;
            }
        }

4、公平锁和非公平锁

        与ReentrantLock一样，ReentrantReadWriteLock也分为公平锁和非公平锁，可以在构造方法中指定，不指定默认就是非公平锁。公平锁和非公平锁都继承自内部同步器Sync，它们的区别仅在writerShouldBlock()和readerShouldBlock()这两个方法的实现上。writerShouldBlock()在tryAcquire()方法中即获取写锁的时候会调用，readerShouldBlock()在tryAcquireShared()方法中即获取写锁的时候会调用。

    public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }

4.1 使用原理

        就是在构造方法的时候给sync属性传入FairLock或NonFairLock对象，然后接下来就用sync来进行锁的操作了。

public class ReentrantReadWriteLock
        implements ReadWriteLock, java.io.Serializable {
    final Sync sync;    // 构造方法中初始化成FairLock或NonFairLock，进行lock和unlock的主要对象
 
    public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }
 
    public ReentrantReadWriteLock() {    this(false);    }
 
    // 自定义同步器，tryAcquire()、tryRelease()等主要方法都在里面实现了
    abstract static class Sync extends AbstractQueuedSynchronizer {...}
 
    // 公平锁，就是一个同步器，特别实现readerShouldBlock()和writerShouldBlock()来实现公平锁
    static final class FairSync extends Sync {...}
 
    // 非公平锁，就是一个同步器，特别实现readerShouldBlock()和writerShouldBlock()来实现非公平锁
    static final class NonfairSync extends Sync {...}

4.2 公平锁

        writerShouldBlock()和readerShouldBlock()都是判断当前节点有没有不是头结点的前驱节点，即是否有线程比当前线程等待更久的时间，有的话返回false，否则true。

    static final class FairSync extends Sync {
        private static final long serialVersionUID = -2274990926593161451L;
        final boolean writerShouldBlock() {
            return hasQueuedPredecessors();    // 判断当前节点有没有不是头结点的前驱节点
        }
        final boolean readerShouldBlock() {
            return hasQueuedPredecessors();
        }
    }
 
    public final boolean hasQueuedPredecessors() {
        Node t = tail; // Read fields in reverse initialization order
        Node h = head;
        Node s;
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

4.3 非公平锁

        获取写锁的线程一定不会阻塞，因为始终返回false。获取读锁的线程，若队列中第一个节点是独占节点，则该线程获取读锁失败，这是为了避免获取写锁一直阻塞。

   static final class NonfairSync extends Sync {
        private static final long serialVersionUID = -8159625535654395037L;
        final boolean writerShouldBlock() {
            return false; // writers can always barge
        }
        final boolean readerShouldBlock() {
            return apparentlyFirstQueuedIsExclusive();    // 队列中第一个节点是否是writer节点
        }
    }