Класс AbstractQueuedSynchronizer

Предоставляет фреймворк для реализации блокирующих замков и связанных синхронизаторов (семафоры, события и т. д.), которые полагаются на очереди ожидания «первым пришёл — первым обслужен» (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()

Вы также можете найти полезными унаследованные методы из 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 , перемежаемых другими вычислениями, прежде чем заблокироваться. Это даёт большинство преимуществ вращений, когда эксклюзивная синхронизация удерживается только на короткий срок, без большей части недостатков, когда это не так. При необходимости вы можете дополнить это, добавив перед вызовами методов acquire проверки «быстрого пути», возможно, предварительно проверив hasContended() и/или hasQueuedThreads() для выполнения этого только в том случае, если синхронизатор, вероятно, не будет оспариваться.

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

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

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

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 acquire и release.

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

Конструкторы

AbstractQueuedSynchronizer

protected AbstractQueuedSynchronizer()

Создаёт новый AbstractQueuedSynchronizer экземпляр с начальным состоянием синхронизации ноль.

Методы

getState

protected final int getState()

Возвращает текущее значение состояния синхронизации. Эта операция имеет семантику памяти для volatile чтения.

Возвращает:

текущее значение состояния

setState

protected final void setState(int newState)

Устанавливает значение состояния синхронизации. Эта операция имеет семантику памяти для volatile записи.

Параметры:

newState - новое значение состояния

compareAndSetState

protected final boolean compareAndSetState(int expect,
                                           int update)

Атомарно устанавливает состояние синхронизации на заданное обновлённое значение, если текущее значение состояния равно ожидаемому значению. Эта операция имеет семантику памяти для volatile чтения и записи.

Параметры:

expect - ожидаемое значение

update - новое значение

Возвращает:

true в случае успеха. Возврат значения False указывает, что фактическое значение не было равно ожидаемому значению.

tryAcquire

protected boolean tryAcquire(int arg)

Параметры:

arg - аргумент приобретения. Это значение всегда передаётся методу acquire или сохраняется при входе в ожидание условия. В противном случае значение не интерпретируется и может представлять собой что угодно.

Возвращает:

true в случае успеха. При успехе, этот объект был приобретён.

Исключения:

IllegalMonitorStateException - если приобретение поставит этот синхронизатор в незаконное состояние. Это исключение должно выбрасываться последовательно для корректной работы синхронизации.

UnsupportedOperationException - если эксклюзивный режим не поддерживается

tryRelease

protected boolean tryRelease(int arg)

Параметры:

arg - аргумент освобождения. Это значение всегда передаётся методу release или текущее значение состояния при входе в ожидание условия. В противном случае значение не интерпретируется и может представлять собой что угодно.

Возвращает:

true если этот объект теперь находится в полностью освобождённом состоянии, так что любые ожидающие потоки могут попытаться приобрести; и false в противном случае.

Исключения:

IllegalMonitorStateException - если освобождение поставит этот синхронизатор в незаконное состояние. Это исключение должно выбрасываться последовательно для корректной работы синхронизации.

UnsupportedOperationException - если эксклюзивный режим не поддерживается

tryAcquireShared

protected int tryAcquireShared(int arg)

Параметры:

arg - аргумент приобретения. Это значение всегда передаётся методу acquire или сохраняется при входе в ожидание условия. В противном случае значение не интерпретируется и может представлять собой что угодно.

Возвращает:

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

Исключения:

IllegalMonitorStateException - если приобретение поставит этот синхронизатор в незаконное состояние. Это исключение должно выбрасываться последовательно для корректной работы синхронизации.

UnsupportedOperationException - если совместный режим не поддерживается

tryReleaseShared

protected boolean tryReleaseShared(int arg)

Параметры:

arg - аргумент освобождения. Это значение всегда передаётся методу release или текущее значение состояния при входе в ожидание условия. В противном случае значение не интерпретируется и может представлять собой что угодно.

Возвращает:

true если это освобождение совместного режима может позволить ожидающему приобретению (совместному или эксклюзивному) пройти успешно; и false в противном случае

Исключения:

IllegalMonitorStateException - если освобождение поставит этот синхронизатор в незаконное состояние. Это исключение должно выбрасываться последовательно для корректной работы синхронизации.

UnsupportedOperationException - если совместный режим не поддерживается

isHeldExclusively

protected boolean isHeldExclusively()

Возвращает:

true если синхронизация удерживается эксклюзивно; false в противном случае

Исключения:

UnsupportedOperationException - если условия не поддерживаются

acquire

public final void acquire(int arg)

Приобретает в эксклюзивном режиме, игнорируя прерывания. Реализуется путём вызова по крайней мере один раз tryAcquire(int), возвращаясь при успехе. В противном случае поток ставится в очередь, возможно, многократно блокируясь и разблокируясь, вызывая tryAcquire(int) до успеха. Этот метод можно использовать для реализации метода Lock.lock().

Параметры:

arg - аргумент приобретения. Это значение передаётся в tryAcquire(int), но в противном случае не интерпретируется и может представлять собой что угодно.

acquireInterruptibly

public final void acquireInterruptibly(int arg)
                                throws InterruptedException

Приобретает в эксклюзивном режиме, прерывая, если прерван. Реализуется путём проверки статуса прерывания, затем вызова по крайней мере один раз tryAcquire(int), возвращаясь при успехе. В противном случае поток ставится в очередь, возможно, многократно блокируясь и разблокируясь, вызывая tryAcquire(int) до успеха или прерывания потока. Этот метод может быть использован для реализации метода Lock.lockInterruptibly().

Параметры:

arg - аргумент приобретения. Это значение передаётся в tryAcquire(int), но в противном случае не интерпретируется и может представлять собой что угодно.

Исключения:

InterruptedException - если текущий поток прерван

tryAcquireNanos

public final boolean tryAcquireNanos(int arg,
                                     long nanosTimeout)
                              throws InterruptedException

Попытка приобретения в эксклюзивном режиме, прерывая, если прерван, и завершаясь, если истечёт заданный таймаут. Реализуется путём проверки статуса прерывания, затем вызова по крайней мере один раз tryAcquire(int), возвращаясь при успехе. В противном случае поток ставится в очередь, возможно, многократно блокируясь и разблокируясь, вызывая tryAcquire(int) до успеха или прерывания потока или истечения таймаута. Этот метод можно использовать для реализации метода Lock.tryLock(long, TimeUnit).

Параметры:

arg - аргумент приобретения. Это значение передаётся в tryAcquire(int), но в противном случае не интерпретируется и может представлять собой что угодно.

nanosTimeout - максимальное количество наносекунд для ожидания

Возвращает:

true если приобретено; false если истек таймаут

Исключения:

InterruptedException - если текущий поток прерван

release

public final boolean release(int arg)

Освобождает в эксклюзивном режиме. Реализуется разблокировкой одного или нескольких потоков, если tryRelease(int) возвращает true. Этот метод можно использовать для реализации метода Lock.unlock().

Параметры:

arg - аргумент освобождения. Это значение передаётся в tryRelease(int), но в противном случае не интерпретируется и может представлять собой что угодно.

Возвращает:

значение, возвращённое из tryRelease(int)

acquireShared

public final void acquireShared(int arg)

Приобретает в режиме совместного использования, игнорируя прерывания. Реализовано путём вызова по крайней мере один раз tryAcquireShared(int), возвращая результат при успехе. В противном случае поток помещается в очередь, возможно, многократно блокируясь и разблокируясь, вызывая tryAcquireShared(int) до достижения успеха.

Параметры:

arg - аргумент приобретения. Это значение передаётся в tryAcquireShared(int), но в остальном не интерпретируется и может представлять собой что угодно.

acquireSharedInterruptibly

public final void acquireSharedInterruptibly(int arg)
                                      throws InterruptedException

Приобретает в режиме совместного использования, прерывая выполнение, если поток прерван. Реализовано путём проверки состояния прерывания, а затем вызова по крайней мере один раз tryAcquireShared(int), возвращая результат при успехе. В противном случае поток помещается в очередь, возможно, многократно блокируясь и разблокируясь, вызывая tryAcquireShared(int) до достижения успеха или прерывания потока.

Параметры:

arg - аргумент приобретения. Это значение передаётся в tryAcquireShared(int), но в остальном не интерпретируется и может представлять собой что угодно.

Исключения:

InterruptedException - если текущий поток прерван

tryAcquireSharedNanos

public final boolean tryAcquireSharedNanos(int arg,
                                           long nanosTimeout)
                                    throws InterruptedException

Попытка приобретения в режиме совместного использования, прерывание, если поток прерван, и отказ, если заданный интервал времени истечёт. Реализовано путём проверки состояния прерывания, а затем вызова по крайней мере один раз tryAcquireShared(int), возвращая результат при успехе. В противном случае поток помещается в очередь, возможно, многократно блокируясь и разблокируясь, вызывая tryAcquireShared(int) до достижения успеха, прерывания потока или истечения срока ожидания.

Параметры:

arg - аргумент приобретения. Это значение передаётся в tryAcquireShared(int), но в остальном не интерпретируется и может представлять собой что угодно.

nanosTimeout - максимальное количество наносекунд ожидания

Возвращает:

true если приобретено; false если истекло время ожидания

Исключения:

InterruptedException - если текущий поток прерван

releaseShared

public final boolean releaseShared(int arg)

Освобождает в режиме совместного использования. Реализовано путём разблокировки одного или нескольких потоков, если tryReleaseShared(int) возвращает true.

Параметры:

arg - аргумент освобождения. Это значение передаётся в tryReleaseShared(int), но в остальном не интерпретируется и может представлять собой что угодно.

Возвращает:

значение, возвращённое из tryReleaseShared(int)

hasQueuedThreads

public final boolean hasQueuedThreads()

Возвращает:

true если могут ожидать другие потоки

hasContended

public final boolean hasContended()

Возвращает:

true если когда-либо была конкуренция

getFirstQueuedThread

public final Thread getFirstQueuedThread()

Возвращает:

первый (самый долго ожидающий) поток в очереди или null , если в настоящее время в очереди нет потоков

isQueued

public final boolean isQueued(Thread thread)

Параметры:

thread - поток

Возвращает:

true если данный поток находится в очереди

Исключения:

NullPointerException - если поток равен null

hasQueuedPredecessors

public final 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
   }
 }

Возвращает:

true если в очереди есть поток, предшествующий текущему потоку, и false если текущий поток находится в голове очереди или очередь пуста

С:

1.7

getQueueLength

public final int getQueueLength()

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

Возвращает:

оценка количества потоков, ожидающих приобретения

getQueuedThreads

public final Collection<Thread> getQueuedThreads()

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

Возвращает:

коллекция потоков

getExclusiveQueuedThreads

public final Collection<Thread> getExclusiveQueuedThreads()

Возвращает коллекцию, содержащую потоки, которые могут ожидать приобретения в режиме исключительного использования. Это имеет те же свойства, что и getQueuedThreads(), за исключением того, что она возвращает только те потоки, которые ожидают из-за исключительного приобретения.

Возвращает:

коллекция потоков

getSharedQueuedThreads

public final Collection<Thread> getSharedQueuedThreads()

Возвращает коллекцию, содержащую потоки, которые могут ожидать приобретения в режиме совместного использования. Это имеет те же свойства, что и getQueuedThreads(), за исключением того, что она возвращает только те потоки, которые ожидают из-за совместного приобретения.

Возвращает:

коллекция потоков

toString

public String toString()

Возвращает строку, идентифицирующую этот синхронизатор, а также его состояние. Состояние, в скобках, включает строку "State =" и текущее значение getState(), а также "nonempty" или "empty" в зависимости от того, пуста ли очередь.

Переопределяет:

toString в классе Object

Возвращает:

строка, идентифицирующая этот синхронизатор, а также его состояние

owns

public final boolean owns(AbstractQueuedSynchronizer.ConditionObject condition)

Определяет, использует ли данный ConditionObject этот синхронизатор в качестве своей блокировки.

Параметры:

condition - условие

Возвращает:

true если принадлежит

Исключения:

NullPointerException - если условие равно null

hasWaiters

public final boolean hasWaiters(AbstractQueuedSynchronizer.ConditionObject condition)

Определяет, ожидают ли какие-либо потоки на данном условии, связанном с этим синхронизатором. Обратите внимание, что из-за таймаутов и прерываний в любое время возврат true не гарантирует, что будущий signal разбудит какие-либо потоки. Этот метод предназначен в основном для мониторинга состояния системы.

Параметры:

condition - условие

Возвращает:

true если есть ожидающие потоки

Исключения:

IllegalMonitorStateException - если исключительная синхронизация не удерживается

IllegalArgumentException - если данное условие не связано с этим синхронизатором

NullPointerException - если условие равно null

getWaitQueueLength

public final int getWaitQueueLength(AbstractQueuedSynchronizer.ConditionObject condition)

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

Параметры:

condition - условие

Возвращает:

оценка количества ожидающих потоков

Исключения:

IllegalMonitorStateException - если исключительная синхронизация не удерживается

IllegalArgumentException - если заданное условие не связано с этим синхронизатором

NullPointerException - если условие равно null

getWaitingThreads

public final Collection<Thread> getWaitingThreads(AbstractQueuedSynchronizer.ConditionObject condition)

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

Параметры:

condition - условие

Возвращает:

коллекцию потоков

Исключения:

IllegalMonitorStateException - если эксклюзивная синхронизация не удерживается

IllegalArgumentException - если заданное условие не связано с этим синхронизатором

NullPointerException - если условие равно null