Java并发之ReentrantReadWriteLock

特征

• ReentrantLock是独占锁， ReentrantReadWriteLock是读写锁
• 多个线程可进入同一个读锁，不能重入一个写锁
• 一个线程不能先进入读锁、再进入写锁
• 类视图
  

成员和构造器

• 默认是非公平锁，非公平锁在在吞吐量上更有优势

    /** Inner class providing readlock */
    private final ReentrantReadWriteLock.ReadLock readerLock;
    /** Inner class providing writelock */
    private final ReentrantReadWriteLock.WriteLock writerLock;
    /** Performs all synchronization mechanics */
    final Sync sync;

    /**
     * Creates a new {@code ReentrantReadWriteLock} with
     * default (nonfair) ordering properties.
     */
    public ReentrantReadWriteLock() {
        this(false);
    }

    /**
     * Creates a new {@code ReentrantReadWriteLock} with
     * the given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }

    public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
    public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }

上锁过程

ReadLock&WriteLock lock过程

读锁

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

   public void lock() {
         sync.acquireShared(1);
     }
      public final void acquireShared(int arg) {
      if (tryAcquireShared(arg) < 0)
          doAcquireShared(arg);
  }  
  在tryAcquireShared(int unused)方法中，如果其他线程已经获取了写锁，则当前线程获取读锁失败，进入等待状态。如果当前线程获取了写锁或者写锁未被获取，则当前线程（线程安全，依靠CAS保证）增加读状态，成功获取读锁。读锁的每次释放（线程安全的，可能有多个读线程同时释放读锁）均减少读状态，减少的值是（1<<16） 
  /**
   * Acquires in shared uninterruptible mode.
   * @param arg the acquire argument
   */
  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;
          }
      } finally {
          if (failed)
              cancelAcquire(node);
      }
  }

写锁

• 写锁是一个支持重进入的排他锁。如果当前线程已经获取了写锁，则增加写状态。如果当前线程在获取写锁时，读锁已经被获取（读状态不为0）或者该线程不是已经获取写锁的线程，则当前线程进入等待状态

  public void lock() {
          sync.acquire(1);
      }
   public final void acquire(int arg) {
      if (!tryAcquire(arg) &&
          acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
          selfInterrupt();
  }
  tryAcquire方法除了重入条件（当前线程为获取了写锁的线程）之外，增加了一个读锁是否存在的判断。如果存在读锁，则写锁不能被获取，原因在于：读写锁要确保写锁的操作对读锁可见，如果允许读锁在已被获取的情况下对写锁的获取，那么正在运行的其他读线程就无法感知到当前写线程的操作。因此，只有等待其他读线程都释放了读锁，写锁才能被当前线程获取，而写锁一旦被获取，则其他读写线程的后续访问均被阻塞。写锁的释放与ReentrantLock的释放过程基本类似，每次释放均减少写状态，当写状态为0时表示写锁已被释放，从而等待的读写线程能够继续访问读写锁，同时前次写线程的修改对后续读写线程可见
      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);
           同步状态不为0，表示至少有一个线程获取了写锁或者读锁
          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;
          }
          //非公平锁都是可直接CAS操作的，公平锁还需要看任务队列是否存在排队
          if (writerShouldBlock() ||
              //自旋操作
              !compareAndSetState(c, c + acquires))
              return false;
           //设置当前拥有独占访问的线程。null 参数表示没有线程拥有访问。此方法不另外施加任何同步或 volatile 字段访问
          setExclusiveOwnerThread(current);
          return true;
      }

• 可以由线程以独占方式拥有的同步器。此类为创建锁和相关同步器（伴随着所有权的概念）提供了基础。AbstractOwnableSynchronizer 类本身不管理或使用此信息。但是，子类和工具可以使用适当维护的值帮助控制和监视访问以及提供诊断。
• 读锁、写锁的操作都是依靠Sync类来实现的，而Sync只是一个抽象类，所以同步的具体实现都是通过NonfairSync和FairSync类

读写锁的状态

• 读写锁的状态

        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;

        /** Returns the number of shared holds represented in count  */
        static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
        /** Returns the number of exclusive holds represented in count  */
        static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

• 假设当前同步状态是S,读锁和写锁的状态获取和设置如下:
• 读锁状态的获取：S >> 16
• 读锁状态的增加：S + (1 << 16)
• 写锁状态的获取：S & 0x0000FFFF
• 写锁状态的增加：S + 1

锁的重入判断–writerShouldBlock/readerShouldBlock

公平锁的重入

• 公平锁的重入都是判断队列中是否有排队的线程

  /**
   * Fair version of Sync
   */
  static final class FairSync extends Sync {
      private static final long serialVersionUID = -2274990926593161451L;
      final boolean writerShouldBlock() {
          return hasQueuedPredecessors();
      }
      final boolean readerShouldBlock() {
          return hasQueuedPredecessors();
      }
  }
       * @return {@code true} if there is a queued thread preceding the
   *         current thread, and {@code false} if the current thread
   *         is at the head of the queue or the queue is empty
   * @since 1.7
   */
  public final boolean hasQueuedPredecessors() {
      // The correctness of this depends on head being initialized
      // before tail and on head.next being accurate if the current
      // thread is first in queue.
      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());
  }
  

非公平锁的重入

• 在 NonFairSync 中说的是 apparentlyFirstQueuedIsExclusive()，即判断阻塞队列中 head 的第一个后继节点是否是来获取写锁的，如果是的话，让这个写锁先来，避免写锁饥饿。
• 在非公平模式下writerShouldBlock永远返回true

    /**
     * Nonfair version of Sync
     */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = -8159625535654395037L;
        final boolean writerShouldBlock() {
            return false; // writers can always barge
        }
        final boolean readerShouldBlock() {
            /* As a heuristic to avoid indefinite writer starvation,
             * block if the thread that momentarily appears to be head
             * of queue, if one exists, is a waiting writer.  This is
             * only a probabilistic effect since a new reader will not
             * block if there is a waiting writer behind other enabled
             * readers that have not yet drained from the queue.
             */
            return apparentlyFirstQueuedIsExclusive();
        }
    }
        /**
     * Returns {@code true} if the apparent first queued thread, if one
     * exists, is waiting in exclusive mode.  If this method returns
     * {@code true}, and the current thread is attempting to acquire in
     * shared mode (that is, this method is invoked from {@link
     * #tryAcquireShared}) then it is guaranteed that the current thread
     * is not the first queued thread.  Used only as a heuristic in
     * ReentrantReadWriteLock.
     */
    final boolean apparentlyFirstQueuedIsExclusive() {
        Node h, s;
        return (h = head) != null &&
            (s = h.next)  != null &&
            !s.isShared()         &&
            s.thread != null;
    }
            /** Marker to indicate a node is waiting in shared mode */
        static final Node SHARED = new Node();
            /**
         * Returns true if node is waiting in shared mode.
         */
        final boolean isShared() {
            return nextWaiter == SHARED;
        }