Класс 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;
 

(Режим совместного использования аналогичен, но может включать каскадные сигналы.)

Поскольку проверки в получении вызываются до помещения в очередь, новый получающий поток может прорваться вперёд других заблокированных и помещённых в очередь. Однако, если необходимо, вы можете определить 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);
   }
 }