Класс 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(java.util.concurrent.locks.AbstractQueuedSynchronizer.Node, int, boolean, boolean, boolean, long), учитывая это сохранённое значение состояния, в конечном счёте восстанавливает этот объект в его предыдущее состояние приобретения. Ни один AbstractQueuedSynchronizer метод иначе не создаёт такую условную переменную, поэтому если это ограничение не может быть выполнено, не используйте её. Поведение AbstractQueuedSynchronizer.ConditionObject конечно зависит от семантики реализации его синхронизатора.

Этот класс предоставляет методы проверки, инструментирования и мониторинга внутренней очереди, а также аналогичные методы для объектов условных переменных. Эти методы могут быть экспортированы по мере необходимости в классы, использующие AbstractQueuedSynchronizer для своих механизмов синхронизации.

Сериализация этого класса сохраняет только лежащий в основе атомный целочисленный тип, поддерживающий состояние, поэтому десериализованные объекты имеют пустые очереди потоков. Типичные подклассы, требующие сериализуемости, определят метод readObject, который восстанавливает это в известное начальное состояние при десериализации.

Использование

Чтобы использовать этот класс в качестве основы синхронизатора, переопределите следующие методы, по мере необходимости, проверяя и/или изменяя состояние синхронизации с использованием getState(), setState(int) и/или compareAndSetState(int, int):

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

Каждый из этих методов по умолчанию вызывает UnsupportedOperationException. Реализации этих методов должны быть внутренне потокобезопасными и, как правило, должны быть короткими и не блокирующими. Определение этих методов — единственный поддерживаемый способ использования этого класса. Все остальные методы объявлены final, потому что они не могут быть независимо изменены.

Вы также можете найти полезными унаследованные методы от 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;
 

(Совместный режим аналогичен, но может включать каскадные сигналы.)

Поскольку проверки в acquire вызываются до помещения в очередь, новый поток, получающий доступ, может пройти вперёд других потоков, которые заблокированы и находятся в очереди. Однако, если нужно, вы можете определить tryAcquire и/или tryAcquireShared для отключения прохождения вперёд, вызвав один или несколько методов проверки, тем самым обеспечив честную очередность FIFO. В частности, большинство справедливых синхронизаторов могут определить tryAcquire для возвращения false, если hasQueuedPredecessors() (метод, специально разработанный для использования справедливыми синхронизаторами) возвращает true. Возможны и другие вариации.

Производительность и масштабируемость, как правило, выше для стратегии прохождения вперёд по умолчанию (также известной как жадная, отказная и избегающая конвоя) стратегия. Хотя это не гарантирует справедливости или отсутствия голодания, более ранние потоки в очереди разрешено повторно конкурировать перед более поздними потоками в очереди, и каждая повторная конкуренция имеет беспристрастный шанс на успех против входящих потоков. Кроме того, хотя захваты не «вращаются» в обычном смысле, они могут выполнять несколько вызовов tryAcquire, чередуя их с другими вычислениями, прежде чем заблокироваться. Это даёт большинство преимуществ вращений, когда исключительная синхронизация удерживается только на короткое время, без большинства недостатков, когда этого нет. При необходимости вы можете дополнить это, выполнив перед вызовами методов приобретения «быстрые пути» проверки, возможно, предварительно проверив hasContended() и/или hasQueuedThreads(), чтобы сделать это только в том случае, если синхронизатор, вероятно, не будет конкурировать.

Этот класс предоставляет эффективную и масштабируемую основу для синхронизации, отчасти специализируясь на синхронизаторах, которые могут полагаться на int состояние, параметры приобретения и освобождения и внутреннюю очередь ожидания FIFO. Когда этого недостаточно, вы можете создать синхронизаторы на более низком уровне, используя классы atomic, свои пользовательские классы Queue и поддержку блокировки LockSupport.

Примеры использования

Вот класс нерекурсивного взаимного исключения, который использует значение ноль для представления разблокированного состояния и единицу для представления заблокированного состояния. Хотя нерекурсивному замку строго не требуется запись текущего владельца потока, этот класс делает это для удобства мониторинга. Он также поддерживает условные переменные и предоставляет некоторые методы инструментирования:

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

Вот класс счётчика, который похож на 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);
   }
 }