AbstractQueuedSynchronizer 类

定义

[Android.Runtime.Register("java/util/concurrent/locks/AbstractQueuedSynchronizer", DoNotGenerateAcw=true)]
public abstract class AbstractQueuedSynchronizer : Java.Util.Concurrent.Locks.AbstractOwnableSynchronizer, IDisposable, Java.Interop.IJavaPeerable

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

继承

Object

Object

AbstractOwnableSynchronizer

AbstractQueuedSynchronizer

属性

RegisterAttribute

实现

IJavaObject IJavaPeerable ISerializable IDisposable

注解

提供一个框架，用于实现依赖于先出（FIFO）等待队列的阻塞锁和相关同步器（信号灯、事件等）。 此类旨在成为大多数依赖于单个原子 int 值来表示状态的同步器的有用基础。 子类必须定义更改此状态的受保护方法，并定义该状态在获取或释放此对象方面的含义。 鉴于这些，此类中的其他方法执行所有队列和阻塞机制。 子类可以维护其他状态字段，但只能维护使用方法#getState操作的原子更新int值，#setState并#compareAndSetState跟踪与同步相关的值。

子类应定义为非公共内部帮助程序类，这些类用于实现其封闭类的同步属性。 类 AbstractQueuedSynchronizer 不实现任何同步接口。 相反，它定义了一些方法，例如 #acquireInterruptibly ，具体锁和相关同步器可以根据需要调用这些方法来实现其公共方法。

此类支持默认 <em>独占</em> 模式和 <em>共享</em> 模式。 以独占模式获取时，其他线程尝试获取的操作无法成功。 多个线程获取的共享模式可能（但不需要）成功。 此类不为 ”understand”除了机械意义上的这些差异，即当共享模式获取成功时，下一个等待线程（如果存在）还必须确定它是否可以获取。 在不同模式下等待的线程共享相同的 FIFO 队列。 通常，实现子类仅支持其中一种模式，但两者都可以发挥作用，例如在一个 ReadWriteLock模式中。 仅支持独占模式或仅共享模式的子类不需要定义支持未使用的模式的方法。

此类定义一个嵌套ConditionObject类，该类可由支持独占模式的子类用作Condition实现，该方法报告是否对当前线程进行独占同步、使用当前#getState值调用的方法#isHeldExclusively#release完全释放此对象，并且#acquire给定此保存的状态值后，最终将此对象还原到其以前的获取状态。 没有 AbstractQueuedSynchronizer 方法否则会创建这样的条件，因此，如果无法满足此约束，请不要使用它。 当然， ConditionObject 其同步器实现的语义取决于其行为。

此类为内部队列提供检查、检测和监视方法，以及条件对象的类似方法。 可以根据需要将这些属性导出到使用同步机制的 AbstractQueuedSynchronizer 类中。

此类的序列化仅存储基础原子整数维护状态，因此反序列化对象具有空线程队列。 需要可序列化的典型子类将定义在 readObject 反序列化时将此还原到已知初始状态的方法。

<h2>用法</h2>

若要将此类用作同步器的基础，请通过检查和/或修改使用#getState#setState和/或#compareAndSetState修改同步状态来重新定义以下方法（如果适用）：

<ul>li li>#tryRelease#tryAcquire><<li>#tryAcquireShared<li li li<>#isHeldExclusively#tryReleaseShared></ul<>

默认情况下，每个方法都会引发 UnsupportedOperationException。 这些方法的实现必须在内部线程安全，通常应短且不阻止。 定义这些方法是<>使用此类的唯<一/em> 支持的方法。 声明所有其他方法 final ，因为它们不能独立变化。

还可以查找继承的方法， AbstractOwnableSynchronizer 以便跟踪拥有独占同步器线程。 建议使用它们 -- 这允许监视和诊断工具帮助用户确定哪些线程持有锁。

尽管此类基于内部 FIFO 队列，但它不会自动强制实施 FIFO 获取策略。 独占同步的核心采用以下形式：

<em>Acquire:</em>
                while (!tryAcquire(arg)) {
<em>enqueue thread if it is not already queued</em>;
<em>possibly block current thread</em>;
                }

<em>Release:</em>
                if (tryRelease(arg))
<em>unblock the first queued thread</em>;

（共享模式类似，但可能涉及级联信号。

由于在排队之前调用了签入获取，因此新获取线程可能会在 <阻止和排队的其他线程之前发出>barge</em> 。 但是，如果需要，可以通过在内部调用一个或多个检查方法来定义tryAcquire和/或tryAcquireShared禁用栏，从而提供<公平></em> FIFO 购置订单。 具体而言，大多数公平的同步器可以定义 tryAcquire 返回 false （ #hasQueuedPredecessors 专门设计为公平同步器使用的方法）返回 true。 其他变体是可能的。

默认条形图（也称为 emgredy</em、<em>>放弃</em> 和 <em>convoy-avoidance</em>>）策略的吞吐量和可伸缩性通常最高。< 虽然这不能保证是公平或无饥饿的，但允许在以后排队的线程之前重新排列较早的排队线程，并且每个重新确认都有一个不偏不平的机会，可以针对传入的线程成功。 此外，虽然获取不是 ”spin”从通常意义上说，在阻止之前，它们可能会执行多个与其他计算交错的调用 tryAcquire 。 当独占同步只是短暂保留时，这给了旋转的大部分好处，而当它不是时，没有大部分责任。 如果需要，可以通过前面的调用来获取具有“快速路径”检查的方法，可能预检查 #hasContended 和/或 #hasQueuedThreads 仅当同步器可能不争用时，才能增强这一点。

此类通过专门将同步范围专用于依赖于 int 状态、获取和释放参数以及内部 FIFO 等待队列的同步器，从而为同步提供高效且可缩放的基础。 如果这不足够，可以使用类、你自己的自定义java.util.Queue类和LockSupport阻止支持从较低级别java.util.concurrent.atomic atomic生成同步器。

<h2>用法示例</h2>

下面是一个非重新进入的相互排除锁类，该类使用值 0 表示解锁状态，一个表示锁定状态。 虽然非重新进入锁不严格要求记录当前所有者线程，但此类仍会这样做，以便更轻松地监视使用情况。 它还支持条件并公开一些检测方法：

{@code
            class Mutex implements Lock, java.io.Serializable {

              // Our internal helper class
              private static class Sync extends AbstractQueuedSynchronizer {
                // Acquires the lock if state is zero
                public boolean tryAcquire(int acquires) {
                  assert acquires == 1; // Otherwise unused
                  if (compareAndSetState(0, 1)) {
                    setExclusiveOwnerThread(Thread.currentThread());
                    return true;
                  }
                  return false;
                }

                // Releases the lock by setting state to zero
                protected boolean tryRelease(int releases) {
                  assert releases == 1; // Otherwise unused
                  if (!isHeldExclusively())
                    throw new IllegalMonitorStateException();
                  setExclusiveOwnerThread(null);
                  setState(0);
                  return true;
                }

                // Reports whether in locked state
                public boolean isLocked() {
                  return getState() != 0;
                }

                public boolean isHeldExclusively() {
                  // a data race, but safe due to out-of-thin-air guarantees
                  return getExclusiveOwnerThread() == Thread.currentThread();
                }

                // Provides a Condition
                public Condition newCondition() {
                  return new ConditionObject();
                }

                // Deserializes properly
                private void readObject(ObjectInputStream s)
                    throws IOException, ClassNotFoundException {
                  s.defaultReadObject();
                  setState(0); // reset to unlocked state
                }
              }

              // The sync object does all the hard work. We just forward to it.
              private final Sync sync = new Sync();

              public void lock()              { sync.acquire(1); }
              public boolean tryLock()        { return sync.tryAcquire(1); }
              public void unlock()            { sync.release(1); }
              public Condition newCondition() { return sync.newCondition(); }
              public boolean isLocked()       { return sync.isLocked(); }
              public boolean isHeldByCurrentThread() {
                return sync.isHeldExclusively();
              }
              public boolean hasQueuedThreads() {
                return sync.hasQueuedThreads();
              }
              public void lockInterruptibly() throws InterruptedException {
                sync.acquireInterruptibly(1);
              }
              public boolean tryLock(long timeout, TimeUnit unit)
                  throws InterruptedException {
                return sync.tryAcquireNanos(1, unit.toNanos(timeout));
              }
            }}

下面是一个闩锁类，就像一个 java.util.concurrent.CountDownLatch CountDownLatch 闩锁类，只是它只需要一个 signal 触发。 由于闩锁是非独占的，因此它使用 shared 获取和释放方法。

{@code
            class BooleanLatch {

              private static class Sync extends AbstractQueuedSynchronizer {
                boolean isSignalled() { return getState() != 0; }

                protected int tryAcquireShared(int ignore) {
                  return isSignalled() ? 1 : -1;
                }

                protected boolean tryReleaseShared(int ignore) {
                  setState(1);
                  return true;
                }
              }

              private final Sync sync = new Sync();
              public boolean isSignalled() { return sync.isSignalled(); }
              public void signal()         { sync.releaseShared(1); }
              public void await() throws InterruptedException {
                sync.acquireSharedInterruptibly(1);
              }
            }}

在 1.5 中添加。

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

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