Класс 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 , который восстанавливает его до известного начального состояния при десериализации.

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

Для использования этого класса в качестве основы синхронизатора переопределите следующие методы, при необходимости, инспектируя и/или изменяя состояние синхронизации с помощью 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);
   }
 }