AbstractQueuedSynchronizer

public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer implements Serializable

为实现依赖于先进先出（FIFO）等待队列的阻塞锁和相关同步器（信号量，事件等）提供框架。 这个类被设计成为依赖于单个原子int值表示状态的大多数同步器的有用基础。 子类必须定义改变此状态的受保护方法，并且定义该状态对于获取或释放此对象的含义。 鉴于这些，本课程中的其他方法将执行所有排队和阻塞机制。 子类可以保持其他状态字段，但只以原子方式更新int使用方法操纵值getState() ， setState(int)和compareAndSetState(int, int)跟踪相对于同步。

应将子类定义为用于实现其封闭类的同步属性的非公共内部辅助类。 AbstractQueuedSynchronizer类没有实现任何同步接口。 相反，它定义了一些方法，例如acquireInterruptibly(int) ，可以通过具体的锁和相关的同步器来适当调用它们来实现它们的公共方法。

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

这个类定义的嵌套AbstractQueuedSynchronizer.ConditionObject ，可用于作为一类Condition由子类支持独占模式用于该方法的实施isHeldExclusively()报告是否同步排他相对于保持在当前线程，方法release(int)与当前调用getState()值完全释放此目的，和acquire(int) ，考虑到这个保存的状态值，最终将该对象恢复到其先前获取的状态。 否则AbstractQueuedSynchronizer方法会创建这样一个条件，所以如果不能满足这个约束条件，就不要使用它。 AbstractQueuedSynchronizer.ConditionObject的行为当然取决于其同步器实现的语义。

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

这个类的序列化只存储基本的原子整数维护状态，所以反序列化的对象具有空的线程队列。 需要可串行化的典型子类将定义一个readObject方法，该方法在解串行化时将其恢复到已知的初始状态。

Usage

使用这个类用作同步的基础上，重新定义以下方法，如适用，通过检查和/或修改使用所述同步状态 getState() ， setState(int)和/或 compareAndSetState(int, int) ：

• tryAcquire(int)
• tryRelease(int)
• tryAcquireShared(int)
• tryReleaseShared(int)
• isHeldExclusively()

您也可以从AbstractOwnableSynchronizer找到继承的方法，以便跟踪拥有独占同步器的线程。 我们鼓励您使用它们 - 这使监视和诊断工具能够帮助用户确定哪些线程持有锁。

尽管此类基于内部FIFO队列，但不会自动执行FIFO采集策略。 独占同步的核心形式如下：

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

 Release:
     if (tryRelease(arg))
        unblock the first queued thread;
 

因为获取中的检查在排队之前被调用，所以新获取的线程可能先于被阻塞和排队的其他线程插入 。 但是，如果需要，您可以通过内部调用一个或多个检查方法来定义tryAcquire和/或tryAcquireShared禁用tryAcquireShared ，从而提供公平的 FIFO采集顺序。 特别地，最公平同步器可以定义tryAcquire返回false如果hasQueuedPredecessors() （具体地设计成由公平同步器中使用的方法）返回true 。 其他变化是可能的。

吞吐量和可扩展性对于默认的驳船（也称为贪婪 ， 放弃和车队避免 ）策略而言通常是最高的。 虽然这不能保证公平或无饥饿，但可以在稍后排队的线程之前重新排队早期排队的线程，并且每次调整都有一个无偏于的机会来抵御传入的线程。 此外，虽然获取不像通常意义上的“旋转”，但在阻塞之前，它们可能会执行多个tryAcquire调用与其他计算tryAcquire交织。 当独占同步只是简单地进行时，这提供了自旋的大部分好处，而当没有大部分的责任时，则没有大部分的责任。 如果需要的话，您可以通过前面的调用来获取这些信息，以获取具有“快速路径”检查的方法，可能需要预先检查hasContended()和/或hasQueuedThreads()以便仅在同步器可能不会被争用时才这样做。

该类为部分同步提供了一种高效的可扩展基础，部分原因是它的使用范围专门用于可依赖int状态，获取和释放参数以及内部FIFO等待队列的同步器。 如果这还不够，可以使用atomic类，自己的自定义Queue类和LockSupport阻止支持从较低级别构建同步器。

Usage Examples

这是一个不可重入的互斥锁类，它使用零值表示解锁状态，一个表示锁定状态。 尽管非重入锁并不严格要求记录当前所有者线程，但该类无论如何都会这样做，以便更易于监视使用。 它还支持条件并公开其中一种工具方法：

 class Mutex implements Lock, java.io.Serializable {

   // Our internal helper class
   private static class Sync extends AbstractQueuedSynchronizer {
     // Reports whether in locked state
     protected boolean isHeldExclusively() {
       return getState() == 1;
     }

     // 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 (getState() == 0) throw new IllegalMonitorStateException();
       setExclusiveOwnerThread(null);
       setState(0);
       return true;
     }

     // Provides a Condition
     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.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));
   }
 }

这是一个闩锁类，就像CountDownLatch ，只是它只需要一个signal触发。 因为锁存器是非排他性的，所以它使用shared获取和释放方法。

 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);
   }
 }

Summary

Inherited methods
From class java.util.concurrent.locks.AbstractOwnableSynchronizer final Thread getExclusiveOwnerThread() 返回最后由 setExclusiveOwnerThread设置的线程或 null如果从未设置）。 final void setExclusiveOwnerThread(Thread thread) 设置当前拥有独占访问权限的线程。
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()方法。

Protected constructors

AbstractQueuedSynchronizer ()

Public methods

void acquire (int arg)

void acquireInterruptibly (int arg)

void acquireShared (int arg)

void acquireSharedInterruptibly (int arg)

Collection<Thread> getExclusiveQueuedThreads ()

Thread getFirstQueuedThread ()

int getQueueLength ()

Collection<Thread> getQueuedThreads ()

Collection<Thread> getSharedQueuedThreads ()

int getWaitQueueLength (AbstractQueuedSynchronizer.ConditionObject condition)

Collection<Thread> getWaitingThreads (AbstractQueuedSynchronizer.ConditionObject condition)

boolean hasContended ()

boolean hasQueuedPredecessors ()

 getFirstQueuedThread() != Thread.currentThread()
   && hasQueuedThreads()

 protected boolean tryAcquire(int arg) {
   if (isHeldExclusively()) {
     // A reentrant acquire; increment hold count
     return true;
   } else if (hasQueuedPredecessors()) {
     return false;
   } else {
     // try to acquire normally
   }
 }

boolean hasQueuedThreads ()

boolean hasWaiters (AbstractQueuedSynchronizer.ConditionObject condition)

boolean isQueued (Thread thread)

boolean owns (AbstractQueuedSynchronizer.ConditionObject condition)

boolean release (int arg)

boolean releaseShared (int arg)

String toString ()

boolean tryAcquireNanos (int arg, 
                long nanosTimeout)

boolean tryAcquireSharedNanos (int arg, 
                long nanosTimeout)

Protected methods

boolean compareAndSetState (int expect, 
                int update)

int getState ()

boolean isHeldExclusively ()

void setState (int newState)

boolean tryAcquire (int arg)

int tryAcquireShared (int arg)

boolean tryRelease (int arg)

boolean tryReleaseShared (int arg)