《Java源码分析》：ReadWriteLock(第二部分)_default (nonfair) ordering properties-CSDN博客

本文链接：https://blog.csdn.net/qq_32440951/article/details/77930732

《Java源码分析》：ReadWriteLock(第二部分)

本篇博文主要介绍了ReentrantReadWriteLock内部实现。

ReadWriteLock是一个接口，如下：

    public interface ReadWriteLock {
        /**
         * Returns the lock used for reading.
         */
        Lock readLock();

        /**
         * Returns the lock used for writing.
         */
        Lock writeLock();
    }
 
 1
2
3
4
5
6
7
8
9
10
11

ReentrantReadWriteLock是ReadWriteLock的实现类。

此类的内部是借助于3个类来完成的。如下

1、Sync。NonFairSync/FairSync。

Sync是继承自AbstractQueuedSynchronizer实现的抽象类，NonFairSync/FairSync都是Sync的子类，分别代表非公平同步器和公平同步器。

2、ReadLock

读锁类，当我们读取数据的时候需要加读锁。

3、WriteLock

写锁类，当我们写数据的时候需要加写锁。

写锁和读锁有一些规则，也是其内部实现的基础。

例如：

1、读锁可以同时被多线程所持有，而写锁只能被一个线程持有且持有的同时不允许其他线程持有读、写锁。

2、可重入性

3、可降级性

4、两个锁所持有的个数由AQS状态位state的高低16来记录。

以上的这些特性都是此类实现的内部基础。

下面我们来分析其内部实现，先冲构造开始。

ReentrantReadWriteLock的构造函数

先看ReentrantReadWriteLock类的构造函数

    /**
     * Creates a new {@code ReentrantReadWriteLock} with
     * default (nonfair) ordering properties.
     */
    public ReentrantReadWriteLock() {
        this(false);//默认创建一个非公平的对象
    }
       /*
        s实例化了AQS的实现类对象，ReadLock、WriteLock对象
       */
    public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

公平锁类FairSync和非公平类NonFairSync都没有提供构造函数
，因此都会调用父类的无参构造函数

       Sync() {
            readHolds = new ThreadLocalHoldCounter();
            setState(getState()); // ensures visibility of readHolds
        }
 
 1
2
3
4

从上面可以看出，如果我们在使用ReentrantReadWriteLock时，使用如下的ReentrantReadWriteLock lock = new ReentrantReadWriteLock();新建一个对象，内部是实例化了sync、readerLock、writeLock三个对象。

WriteLock的lock()的内部实现

先来介绍写锁的lock()/unlock()的内部实现。

WriteLock的lock()的实现源码如下：

        public void lock() {
            sync.acquire(1);
        }
        /*
            此函数的思路为：
            1、调用tryAcquire获取独占锁，如果没有获取到，则进行2
            2、调用addWaiter函数将节点加入队列中，进行3
            3、一直自旋，直到其获得锁
        */
        public final void acquire(int arg) {
            if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                selfInterrupt();
        }


        protected final boolean tryAcquire(int acquires) {
            /*
             * Walkthrough:
             * 1. If read count nonzero or write count nonzero
             *    and owner is a different thread, fail.
             * 2. If count would saturate, fail. (This can only
             *    happen if count is already nonzero.)
             * 3. Otherwise, this thread is eligible for lock if
             *    it is either a reentrant acquire or
             *    queue policy allows it. If so, update state
             *    and set owner.
             */
            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;
        }
        //NonfairSync类中的写一直不阻塞
        final boolean writerShouldBlock() {
            return false; // writers can always barge
        }
        //FairSync类中的

        final boolean writerShouldBlock() {
            return hasQueuedPredecessors();//队列中是否其它线程的节点
        }
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

写锁的lock()和unlock()的过程可以与独占锁ReentrantLock类似来理解，相信看过ReentrantLock源码后的我们理解这些代码是比较容易的了。

大概思想总结一下：

一个线程想获取写锁，所经历的过程如下

1、由于写锁是独占锁，首先肯定是判断写锁有没有被其它线程拥有，由于写锁不能和读锁共存，因此也要判断读锁有没有被其它线程(也包括自己)拥有。如果以上情况均不符合，则此线程得到锁，立即返回并设置AQS状态位。否则进行2

2、将此线程加入到AQS队列中并进行自旋等待获取锁直至此线程获取到锁。

ReadLock的lock()的内部实现

读锁lock()、unlock()方法的思想可以与共享锁Semaphore、CountDownLatch类似来理解。但是比Semaphore、CountDownLatch稍微要复杂一点。

这是因为ReadLock加锁成功与否还和WriteLock有一定的关系。

下面我们具体来看看

        /**
         * Acquires the read lock.
         *
         * <p>Acquires the read lock if the write lock is not held by
         * another thread and returns immediately.
         *当写锁没有被其它线程持有，则获取一个读锁并立即返回
         *如果写锁被其它线程持有，则由于线程调度的原因当前线程被禁用，休眠直至读锁被获取到。
         * <p>If the write lock is held by another thread then
         * the current thread becomes disabled for thread scheduling
         * purposes and lies dormant until the read lock has been acquired.
         */
        public void lock() {
            sync.acquireShared(1);
        }
        public final void acquireShared(int arg) {
            if (tryAcquireShared(arg) < 0)
                doAcquireShared(arg);
        }

        protected final int tryAcquireShared(int unused) {
            /*
             * Walkthrough:
             * 1. If write lock held by another thread, fail.
             否则，该线程是有资格获得读锁的，因此根据队列的实际情况此线程是否需要被阻塞，
             如果不需要，则获得锁并利用CAS来更新AQS同步队列的状态位。
             注意：这一步不检查重入。
             * 2. Otherwise, this thread is eligible(有资格的) for
             *    lock wrt state, so ask if it should block
             *    because of queue policy. If not, try
             *    to grant by CASing state and updating count.
             *    Note that step does not check for reentrant
             *    acquires, which is postponed to full version
             *    to avoid having to check hold count in
             *    the more typical non-reentrant case.
             * 3. If step 2 fails either because thread
             *    apparently not eligible or CAS fails or count
             *    saturated, chain to version with full retry loop.
             */
            Thread current = Thread.currentThread();
            int c = getState();
            if (exclusiveCount(c) != 0 &&
                getExclusiveOwnerThread() != current)//写锁被其它的线程占有，则立即返回
                return -1;
            int r = sharedCount(c);//读锁的个数
            /*
                如果此线程不应该被阻塞且读锁的个数小于最大锁的限制且CAS设置成功
            */
            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);
        }

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68