关于java:AQS用写公司简章方式理解读写锁ReentrantReadWriteLock

3次阅读

共计 3307 个字符，预计需要花费 9 分钟才能阅读完成。

读写锁，顾名思义。这是一种对于两种不同行为的同步器工具，而读写是两种互斥的行为（写的时候，不能读。读的时候不能写），因而 ReentrantReadWriteLock 锁也具备此个性。

设想一下，你正在写一份公司外部治理的简章，而笔只有一支（写锁），所以只有当你拿到这只笔（获取写锁）后才能够写内容。写完后（开释锁），简章就能够张贴进来让共事去浏览了（同时浏览：读锁）。然而这个时候你发现简章上写的有些问题，须要从新批改一下。不过你须要等你这些共事看齐全部来到之后（开释读锁），你才能够拿着笔（写锁）去批改简章。批改实现后，为了保障这次写的没有问题，你决定本人先检查一下（持有写锁，再持有读锁），OK 后你放下笔（开释写锁，这个过程就交锁降级：写锁 -> 读锁），而后又把它张贴到布告栏中，让共事们去观看。

2

源码解析

这里只有来学习其设计，对于偏心锁非偏心锁，以及可重入的概念不再赘述，不太分明的可参考 AQS- 用配钥匙和保险箱了解可重入锁（ReentrantLock）这篇文章的解析。读写锁也是通过继承 AQS 同步器来实现其性能的，它同时应用了排他锁（写锁）和共享锁（读锁），当初看它是怎么实现将读锁和写锁关联起来的。

构造函数：

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

读写锁，最终应用的都是这里结构的 sync 对象，依据 fair 参数生成偏心锁或非偏心锁。接下来咱们来看一下读锁的获取 / 开释，以及写锁的获取 / 开释。


// 读锁
        public void lock() {sync.acquireShared(1);
        }
        public void unlock() {sync.releaseShared(1);
        }
// 写锁
          public void lock() {sync.acquire(1);
        }

         public void unlock() {sync.release(1);
        }

能够看到的是，读锁应用的是共享锁逻辑，而写锁用的是排他锁的逻辑，同时要留神其可重入的。这些都很简略的，咱们后面的文章都有讲述到。这里的难点是读锁和写锁到底是这么关联的？解析源码前，咱们先来看一下 Sync 这个 class 的成员信息, 咱们就能明确了 ReentrantReadWriteLock 是怎么实现的了：

        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;

        /** 借出共享锁数量 */
        static int sharedCount(int c)    {return c >>> SHARED_SHIFT;}
        /** 写锁的数量 */
        static int exclusiveCount(int c) {return c & EXCLUSIVE_MASK;}

设计者将 int32 分为两局部：前 16 位（存储读锁信息），后 16 位（存储写锁信息）。咱们再依据其提供的 sharedCount，exclusiveCount 办法名就能够明确，ReentrantReadWriteLock 读写锁就是 获取读锁数量 和写锁数量 来实现关联，从而实现互斥性能。当初咱们来看一下理论代码：

读锁：


// 读锁 lock  sync.acquireShared(1)最终调用 tryReleaseShared
  protected final int tryAcquireShared(int unused) {Thread current = Thread.currentThread();
            int c = getState();
            if (exclusiveCount(c) != 0 &&  ## 1
                getExclusiveOwnerThread() != current)  //  判断是否能够锁降级（持有写锁的，获取读锁）return -1; // 失败。因为曾经有人持有写锁了
            int r = sharedCount(c); // 读锁的数量
            if (!readerShouldBlock() && ## 2
                r < MAX_COUNT &&
                compareAndSetState(c, c + SHARED_UNIT)) {if (r == 0) {   ## 3
                    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); // 完整版，用了 for 循环，代码相似不赘述。}

阐明下代码：

1：if (exclusiveCount(c) != 0 && getExclusiveOwnerThread() != current) 代码实现的是读写锁的互斥以及写锁的降级。解释一下：写锁数量不为 0，以后线程不是索取写锁的线程。只有 if 为 false 能力获取读锁, 有以下两种情状况：a 以后没有线程写锁; b. 是以后线程获取写锁。

2：这里的逻辑就是获取读锁，应用了 CAS。

3：这里阐明一下：firstReader和 cachedHoldCounter 记录第一个和最初一个线程是为了优化获取锁的效率。firstReader（只有一个线程时反复获取锁）。cachedHoldCounter（最初一个获取锁的线程反复获取锁）。因为这两种状况最有可能产生。

写锁：

// 写锁 lock  sync.acquireShared(1)最终调用 tryReleaseShared
 protected final boolean tryAcquire(int acquires) {Thread current = Thread.currentThread();
            int c = getState(); // 状态值
            int w = exclusiveCount(c); // 写锁数量
            if (c != 0) { ## 1
                // (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;
        }

1：状态值 state 不为 0，意味着有线程持有锁（写锁，读锁）。if (w == 0 || current != getExclusiveOwnerThread())，写锁数量为 0，那么当初还有读锁未开释，获取失败。如果写锁数量不为 0，但不是以后线程则不可重入。

对于读写锁的开释比较简单，这里就不再解析了。同时须要说一声的是对于 java AQS 这块源码学习就先到这了。

正文完