ReentrantReadWriteLock 类

定义

[Android.Runtime.Register("java/util/concurrent/locks/ReentrantReadWriteLock", DoNotGenerateAcw=true)]
public class ReentrantReadWriteLock : Java.Lang.Object, IDisposable, Java.Interop.IJavaPeerable, Java.IO.ISerializable, Java.Util.Concurrent.Locks.IReadWriteLock

[<Android.Runtime.Register("java/util/concurrent/locks/ReentrantReadWriteLock", DoNotGenerateAcw=true)>]
type ReentrantReadWriteLock = class
    inherit Object
    interface ISerializable
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable
    interface IReadWriteLock

继承

Object

Object

ReentrantReadWriteLock

属性

RegisterAttribute

实现

IJavaObject IJavaPeerable ISerializable IReadWriteLock IDisposable

注解

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

此类具有以下属性：

<ul><li><b>Acquisition order</b>

此类不会对锁访问施加读取器或编写器首选项排序。 但是，它确实支持可选的 <em>fairness</em> 策略。

<dl><dt><b>非公平模式（default）</b><dd>构造为非公平（默认值），读取和写入锁的输入顺序不受指定，但受重新进入约束的约束。 连续争用的非打开锁可能会无限期地推迟一个或多个读取器或写入器线程，但通常吞吐量将高于公平锁。

<dt><b>Fair mode</b><dd>当构造为公平时，线程会争用近似到达顺序策略进入。 释放当前保留的锁时，将分配最长等待的单个写入器线程，或者如果有一组读取器线程等待的时间长于所有等待的写入器线程，则会为该组分配读取锁。

尝试获取公平读取锁（非重新进入）的线程会在保留写入锁或存在等待的编写器线程时阻止。 在最早的当前等待编写器线程获取并释放写入锁之后，线程才会获取读取锁。 当然，如果等待编写器放弃等待，将一个或多个读取器线程保留为队列中最长的等待程序，并释放写入锁定，则将为这些读取器分配读取锁。

尝试获取公平写入锁（非重新进入）的线程将阻止，除非读取锁和写入锁都是免费的（这意味着没有等待的线程）。 （请注意，非阻塞 ReadLock#tryLock() 和 WriteLock#tryLock() 方法不遵循此公平设置，并且无论等待线程如何，都将立即获取锁。 </dl>

<li><b>Reentrancy</b>

此锁允许读取器和编写器重新获取读取或写入锁的 ReentrantLock样式。 在释放写入线程持有的所有写入锁之前，不允许非重新进入的读取器。

此外，编写器可以获取读取锁，但反之亦然。 在其他应用程序中，在调用期间保留写入锁或回调执行读取锁定的方法时，重新进入非常有用。 如果读取器尝试获取写入锁，则永远不会成功。

<li><b>锁定降级</b>

重新进入还允许从写入锁降级到读取锁，方法是获取写入锁，然后读取锁，然后释放写入锁。 但是，无法从读取锁升级到写入锁<<>>。

<li><b>锁定获取<中断/b>

读取锁和写入锁都支持在锁定获取期间中断。

<li><b>Condition 支持</b>

写入锁提供与Condition写入锁相同的方式的实现，就像为ReentrantLock#newConditionReentrantLock写入锁提供的实现一样Condition。 当然，这 Condition 只能与写入锁一起使用。

读取锁不支持 Condition 并 readLock().newCondition() 引发 UnsupportedOperationException。

<li><b>Instrumentation</b>

此类支持确定锁是保留还是争用的方法。 这些方法旨在监视系统状态，而不是用于同步控制。 </ul>

此类的序列化与内置锁的行为方式相同：反序列化锁处于解锁状态，而不考虑序列化时的状态。

<b>示例用法。</b> 下面是一个代码草图，显示如何在更新缓存后执行锁定降级（以非嵌套方式处理多个锁时异常处理特别棘手）：

{@code
            class CachedData {
              Object data;
              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();
                }
              }
            }}

ReentrantReadWriteLocks 可用于改进某些集合的一些用途中的并发性。 这通常是值得的，前提是集合预期较大，读取器线程比编写器线程访问的线程多，并且需要开销超过同步开销的操作。 例如，下面是一个使用 TreeMap 的类，该类应是大型且并发访问的。

{@code
            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(); }
              }
            }}

<h2>实现说明</h2>

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

在 1.5 中添加。

Java文档java.util.concurrent.locks.ReentrantReadWriteLock。

本页的某些部分是根据 创建和共享的工作进行的修改，并根据 许可证中所述的条款使用。