ReentrantReadWriteLock

public class ReentrantReadWriteLock
extends Object implements ReadWriteLock, Serializable

一个实现 ReadWriteLock支持类似的语义到 ReentrantLock 。

这个类有以下属性：

• Acquisition order

  该类不强制为锁访问订购读者或写者偏好。 但是，它支持可选的公平策略。

  Non-fair mode (default)

  When constructed as non-fair (the default), the order of entry to the read and write lock is unspecified, subject to reentrancy constraints. A nonfair lock that is continuously contended may indefinitely postpone one or more reader or writer threads, but will normally have higher throughput than a fair lock.

  Fair mode

  When constructed as fair, threads contend for entry using an approximately arrival-order policy. When the currently held lock is released, either the longest-waiting single writer thread will be assigned the write lock, or if there is a group of reader threads waiting longer than all waiting writer threads, that group will be assigned the read lock.

  尝试获得公平读取锁定（非重复）的线程会阻止写入锁定，或者存在等待写入器线程。 直到最早的当前正在等待的写入线程获取并释放写入锁定之后，线程才会获取读取锁定。 当然，如果一个等待写作者放弃等待，留下一个或多个读者线程作为队列中最长的等待者并且写锁定是空闲的，那么这些读者将被分配读锁。

  除非读锁和写锁都是空闲的（这意味着没有等待线程），否则试图获得公平写锁的线程（非再生）将被阻塞。 （请注意，非阻塞tryLock()和tryLock()方法不符合此公平设置，并且如果可能，将立即获取该锁，而不管等待的线程如何。）

• Reentrancy

  此锁允许读者和作者以ReentrantLock的样式重新获取读取或写入锁定。 直到写入线程持有的所有写入锁定都被释放后才允许不可重入读取器。

  另外，作者可以获取读锁，但反之亦然。 在其他应用程序中，当在执行读取锁定下执行读取的方法的调用或回调期间保持写入锁定时，重新进入可能很有用。 如果读者试图获得写入锁，它永远不会成功。

• Lock downgrading

  重入还允许通过获取写入锁定，然后读取锁定，然后释放写入锁定，从写入锁定降级到读取锁定。 然而，从读锁定写锁定升级是不可能的。

• Interruption of lock acquisition

  读取锁定和写入锁定均支持锁定采集期间的中断。

• Condition support

  写锁提供了一个Condition实现，其行为与写锁相同，因为Condition提供的newCondition()实现为ReentrantLock提供了实现。 当然，这个Condition只能与写入锁一起使用。

  读锁不支持 Condition和 readLock().newCondition()抛出 UnsupportedOperationException 。

• Instrumentation

  该类支持确定锁是持有还是争用的方法。 这些方法用于监视系统状态，而不是用于同步控制。

该类的序列化行为与内置锁的行为相同：反序列化的锁处于解锁状态，无论序列化时的状态如何。

样本用法 。 下面是一段代码草图，展示了如何在更新缓存后执行锁定降级（当以非嵌套方式处理多个锁时，异常处理特别棘手）：

 class CachedData {
   Object data;
   volatile boolean cacheValid;
   final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

   void processCachedData() {
     rwl.readLock().lock();
     if (!cacheValid) {
       // Must release read lock before acquiring write lock
       rwl.readLock().unlock();
       rwl.writeLock().lock();
       try {
         // Recheck state because another thread might have
         // acquired write lock and changed state before we did.
         if (!cacheValid) {
           data = ...
           cacheValid = true;
         }
         // Downgrade by acquiring read lock before releasing write lock
         rwl.readLock().lock();
       } finally {
         rwl.writeLock().unlock(); // Unlock write, still hold read
       }
     }

     try {
       use(data);
     } finally {
       rwl.readLock().unlock();
     }
   }
 }

 class RWDictionary {
   private final Map<String, Data> m = new TreeMap<>();
   private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
   private final Lock r = rwl.readLock();
   private final Lock w = rwl.writeLock();

   public Data get(String key) {
     r.lock();
     try { return m.get(key); }
     finally { r.unlock(); }
   }
   public List<String> allKeys() {
     r.lock();
     try { return new ArrayList<>(m.keySet()); }
     finally { r.unlock(); }
   }
   public Data put(String key, Data value) {
     w.lock();
     try { return m.put(key, value); }
     finally { w.unlock(); }
   }
   public void clear() {
     w.lock();
     try { m.clear(); }
     finally { w.unlock(); }
   }
 }

Implementation Notes

此锁最多支持65535个递归写入锁定和65535个读取锁定。 尝试超出这些限制会导致Error从锁定方法中抛出。

Summary

Inherited methods
From class java.lang.Object Object clone() 创建并返回此对象的副本。 boolean equals(Object obj) 指示其他某个对象是否“等于”这一个。 void finalize() 当垃圾收集确定没有更多对该对象的引用时，由对象上的垃圾回收器调用。 final Class<?> getClass() 返回此 Object的运行时类。 int hashCode() 返回对象的哈希码值。 final void notify() 唤醒正在等待该对象监视器的单个线程。 final void notifyAll() 唤醒在该对象监视器上等待的所有线程。 String toString() 返回对象的字符串表示形式。 final void wait(long millis, int nanos) 导致当前线程等待，直到另一个线程为该对象调用 notify()方法或 notifyAll()方法，或者某个其他线程中断当前线程，或者经过了一定的实时时间。 final void wait(long millis) 导致当前线程等待，直到另一个线程调用此对象的 notify()方法或 notifyAll()方法或经过指定的时间量。 final void wait() 导致当前线程等待，直到另一个线程调用此对象的 notify()方法或 notifyAll()方法。
From interface java.util.concurrent.locks.ReadWriteLock abstract Lock readLock() 返回用于读取的锁。 abstract Lock writeLock() 返回用于写入的锁。

Public constructors

ReentrantReadWriteLock ()

ReentrantReadWriteLock (boolean fair)

Public methods

int getQueueLength ()

int getReadHoldCount ()

int getReadLockCount ()

int getWaitQueueLength (Condition condition)

int getWriteHoldCount ()

boolean hasQueuedThread (Thread thread)

boolean hasQueuedThreads ()

boolean hasWaiters (Condition condition)

boolean isFair ()

boolean isWriteLocked ()

boolean isWriteLockedByCurrentThread ()

ReentrantReadWriteLock.ReadLock readLock ()

String toString ()

ReentrantReadWriteLock.WriteLock writeLock ()

Protected methods

Thread getOwner ()

Collection<Thread> getQueuedReaderThreads ()

Collection<Thread> getQueuedThreads ()

Collection<Thread> getQueuedWriterThreads ()

Collection<Thread> getWaitingThreads (Condition condition)