AbstractQueuedSynchronizer (Платформа Java SE 7)

java.lang. Объект
- java.util.concurrent.locks.AbstractOwnableSynchronizer
- - java.util.concurrent.locks.AbstractQueuedSynchronizer

Все Реализованные Интерфейсы:

Сериализуемый
```
public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer
implements Serializable
```
Служит основой для того, чтобы реализовать блокировки блокирования и связанные синхронизаторы (семафоры, события, и т.д.), которые полагаются первым прибыл - первым убыл (FIFO), ожидают очереди. Этот класс разрабатывается, чтобы быть полезным основанием для большинства видов синхронизаторов, которые полагаются на единственное атомарное значение int, чтобы представить состояние. Подклассы должны определить защищенные методы, которые изменяют это состояние, и которые определяют то, что то состояние означает с точки зрения этого объекта, получаемого или выпущенного. Учитывая их, другие методы в этом классе выполняют всю организацию очередей и блокирование механики. Подклассы могут поддержать другие поля состояния, но только атомарно обновленное значение int, которым управляют, используя методы getState(), setState(int) и compareAndSetState(int, int) прослеживается относительно синхронизации.
Подклассы должны быть определены как непубличные внутренние классы помощника, которые используются, чтобы реализовать свойства синхронизации их класса включения. Класс AbstractQueuedSynchronizer не реализует интерфейса синхронизации. Вместо этого это определяет методы такой как acquireInterruptibly(int) это может быть вызвано как соответствующее конкретными блокировками и связанными синхронизаторами, чтобы реализовать их открытые методы.
Этот класс поддерживает или или и монопольный режим по умолчанию и совместно используемый режим. Когда получено в монопольном режиме, предпринятом, получает другими потоками, не может успешно выполниться. Совместно используемый режим получает многократными потоками, может (но нуждаться не), успешно выполняются. Этот класс не "понимает" эти различия кроме в механическом смысле, который, когда совместно используемый режим получают, успешно выполняется, следующий поток ожидания (если Вы существуете), должен также определить, может ли это получить также. Потоки, ожидающие в различных режимах, совместно используют ту же самую очередь FIFO. Обычно, подклассы реализации поддерживают только один из этих режимов, но оба могут играть роль например в a ReadWriteLock. Подклассы, которые поддерживают только монопольные или только совместно используемые режимы, не должны определить методы, поддерживающие неиспользованный режим.
Этот класс определяет вложенный AbstractQueuedSynchronizer.ConditionObject класс, который может использоваться в качестве a Condition реализация та, подклассами, поддерживающими монопольный режим, для который метод isHeldExclusively() отчеты, сохранена ли синхронизация исключительно относительно текущего потока, метода release(int) вызванный с током getState() значение полностью выпускает этот объект, и acquire(int), учитывая это сохраненное значение состояния, в конечном счете восстанавливает этот объект к его предыдущему полученному состоянию. Никакой метод AbstractQueuedSynchronizer иначе не создает такое условие, так, если это ограничение не может быть встречено, не используйте это. Поведение AbstractQueuedSynchronizer.ConditionObject зависит, конечно, от семантики его реализации синхронизатора.
Этот класс обеспечивает контроль, инструментарий, и контролирующие методы для внутренней очереди, так же как подобные методы для объектов условия. Они могут быть экспортированы как требующийся в классы, используя AbstractQueuedSynchronizer для их механики синхронизации.
Сериализация этого класса хранит только базовое атомарное целочисленное состояние поддержания, таким образом, у десериализованных объектов есть пустые очереди потока. Типичные подклассы, требующие сериализуемости, определят метод readObject, который восстанавливает это к известному начальному состоянию на десериализацию.
Использование

Чтобы использовать этот класс в качестве основания синхронизатора, пересмотрите следующие методы, как применимые, осматривая и/или изменяя использование состояния синхронизации getState(), setState(int) и/или compareAndSetState(int, int):
Каждый из этих методов бросками по умолчанию 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 {
     // Report whether in locked state
     protected boolean isHeldExclusively() {
       return getState() == 1;
     }

     // Acquire 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;
     }

     // Release 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;
     }

     // Provide a Condition
     Condition newCondition() { return new ConditionObject(); }

     // Deserialize 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));
   }
 }
 
```
Вот класс фиксатора, который походит на a 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);
   }
 }
 
```
С тех пор:

1.5

См. Также:
Сериализированная Форма

Вложенная Сводка Класса

Вложенные Классы
Модификатор и Тип	Класс и Описание
`class`	`AbstractQueuedSynchronizer.ConditionObject` Реализация условия для a `AbstractQueuedSynchronizer` служение в качестве основания a `Lock` реализация.

Сводка конструктора

Конструкторы
Модификатор	Конструктор и Описание
`protected`	`AbstractQueuedSynchronizer()` Создает новый экземпляр `AbstractQueuedSynchronizer` с начальным состоянием синхронизации нуля.

Сводка метода

Методы
Модификатор и Тип	Метод и Описание
`void`	`acquire(int arg)` Получает в монопольном режиме, игнорируя прерывания.
`void`	`acquireInterruptibly(int arg)` Получает в монопольном режиме, прерываясь если прервано.
`void`	`acquireShared(int arg)` Получает в совместно используемом режиме, игнорируя прерывания.
`void`	`acquireSharedInterruptibly(int arg)` Получает в совместно используемом режиме, прерываясь если прервано.
`protected boolean`	`compareAndSetState(int expect, int update)` Атомарно синхронизация наборов утверждает к данному обновленному значению, если значение текущего состояния равняется математическому ожиданию.
`Collection<Thread>`	`getExclusiveQueuedThreads()` Возвращает набор, содержащий потоки, которые могут ожидать, чтобы получить в монопольном режиме.
`Поток`	`getFirstQueuedThread()` Возвращает первый (дольше всего ожидающий) поток в очереди, или `null` если никакие потоки в настоящий момент не ставятся в очередь.
`Collection<Thread>`	`getQueuedThreads()` Возвращает набор, содержащий потоки, которые могут ожидать, чтобы получить.
`int`	`getQueueLength()` Возвращает оценку числа потоков, ожидающих, чтобы получить.
`Collection<Thread>`	`getSharedQueuedThreads()` Возвращает набор, содержащий потоки, которые могут ожидать, чтобы получить в совместно используемом режиме.
`protected int`	`getState()` Возвращает текущую стоимость состояния синхронизации.
`Collection<Thread>`	`getWaitingThreads(AbstractQueuedSynchronizer.ConditionObject condition)` Возвращает набор, содержащий те потоки, которые могут ожидать на данном условии, связанном с этим синхронизатором.
`int`	`getWaitQueueLength(AbstractQueuedSynchronizer.ConditionObject condition)` Возвращает оценку числа потоков, ожидающих на данном условии, связанном с этим синхронизатором.
`boolean`	`hasContended()` Запросы, спорили ли какие-либо потоки когда-либо, чтобы получить этот синхронизатор; это - то, если получать метод когда-либо блокировал.
`boolean`	`hasQueuedPredecessors()` Запросы, ожидали ли какие-либо потоки, чтобы получить дольше чем текущий поток.
`boolean`	`hasQueuedThreads()` Запросы, ожидают ли какие-либо потоки, чтобы получить.
`boolean`	`hasWaiters(AbstractQueuedSynchronizer.ConditionObject condition)` Запросы, ожидают ли какие-либо потоки на данном условии, связанном с этим синхронизатором.
`protected boolean`	`isHeldExclusively()` Возвраты `true` если синхронизация считается исключительно относительно текущего (вызов) потоком.
`boolean`	`isQueued(Thread thread)` Возвращает true, если данный поток в настоящий момент ставится в очередь.
`boolean`	`owns(AbstractQueuedSynchronizer.ConditionObject condition)` Запросы, использует ли данный ConditionObject этот синхронизатор в качестве своей блокировки.
`boolean`	`release(int arg)` Выпуски в монопольном режиме.
`boolean`	`releaseShared(int arg)` Выпуски в совместно используемом режиме.
`protected void`	`setState(int newState)` Устанавливает значение состояния синхронизации.
`Строка`	`toString()` Возвращает строку, идентифицирующую этот синхронизатор, так же как его состояние.
`protected boolean`	`tryAcquire(int arg)` Попытки получить в монопольном режиме.
`boolean`	`tryAcquireNanos(int arg, long nanosTimeout)` Попытки получить в монопольном режиме, прерываясь если прервано, и перестав работать, если данный тайм-аут протекает.
`protected int`	`tryAcquireShared(int arg)` Попытки получить в совместно используемом режиме.
`boolean`	`tryAcquireSharedNanos(int arg, long nanosTimeout)` Попытки получить в совместно используемом режиме, прерываясь если прервано, и перестав работать, если данный тайм-аут протекает.
`protected boolean`	`tryRelease(int arg)` Попытки установить состояние, чтобы отразить выпуск в монопольном режиме.
`protected boolean`	`tryReleaseShared(int arg)` Попытки установить состояние, чтобы отразить выпуск в совместно используемом режиме.

Методы, унаследованные от класса java.util.concurrent.locks.AbstractOwnableSynchronizer
getExclusiveOwnerThread, setExclusiveOwnerThread

Методы java.lang унаследованный от класса. Объект
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Деталь конструктора
  - 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 - новое значение
    
    Возвраты:
    истина в случае успеха. Ложный возврат указывает, что фактическое значение не было равно математическому ожиданию.
  - tryAcquire
```
protected boolean tryAcquire(int arg)
```
    Попытки получить в монопольном режиме. Этот метод должен запросить, разрешает ли состояние объекта этому быть полученным в монопольном режиме, и раз так получать его.
    Этот метод всегда вызывается выполнением потока, получают. Если этот отказ отчетов метода, получать метод может поставить поток в очередь, если это уже не ставится в очередь, пока это не сообщается выпуском от некоторого другого потока. Это может использоваться, чтобы реализовать метод Lock.tryLock().
    Броски реализации по умолчанию UnsupportedOperationException.
    
    Параметры:
    arg - получать параметр. Это значение всегда является тем, которое передают к получать методу, или является значением, на котором экономят, запись в условие ожидает. Значение иначе неинтерпретируется и может представить что-либо, что Вы любите.
    
    Возвраты:
    true в случае успеха. На успех был получен этот объект.
    
    Броски:
    
    IllegalMonitorStateException - если получение поместило бы этот синхронизатор в недопустимое состояние. Это исключение должно быть выдано непротиворечивым способом для синхронизации, чтобы работать правильно.
    
    UnsupportedOperationException - если монопольный режим не поддерживается
  - tryRelease
```
protected boolean tryRelease(int arg)
```
    Попытки установить состояние, чтобы отразить выпуск в монопольном режиме.
    Этот метод всегда вызывается выпуском выполнения потока.
    Броски реализации по умолчанию UnsupportedOperationException.
    
    Параметры:
    arg - параметр выпуска. Это значение всегда является тем, которое передают к методу выпуска, или значение текущего состояния после записи в условие ожидает. Значение иначе неинтерпретируется и может представить что-либо, что Вы любите.
    
    Возвраты:
    true если этот объект находится теперь в полностью выпущенном состоянии, так, чтобы любые потоки ожидания могли попытаться получить; и false иначе.
    
    Броски:
    
    IllegalMonitorStateException - если выпуск поместил бы этот синхронизатор в недопустимое состояние. Это исключение должно быть выдано непротиворечивым способом для синхронизации, чтобы работать правильно.
    
    UnsupportedOperationException - если монопольный режим не поддерживается
  - tryAcquireShared
```
protected int tryAcquireShared(int arg)
```
    Попытки получить в совместно используемом режиме. Этот метод должен запросить, разрешает ли состояние объекта этому быть полученным в совместно используемом режиме, и раз так получать его.
    Этот метод всегда вызывается выполнением потока, получают. Если этот отказ отчетов метода, получать метод может поставить поток в очередь, если это уже не ставится в очередь, пока это не сообщается выпуском от некоторого другого потока.
    Броски реализации по умолчанию UnsupportedOperationException.
    
    Параметры:
    arg - получать параметр. Это значение всегда является тем, которое передают к получать методу, или является значением, на котором экономят, запись в условие ожидает. Значение иначе неинтерпретируется и может представить что-либо, что Вы любите.
    
    Возвраты:
    отрицательная величина при отказе; обнулите, если сбор в совместно используемом режиме успешно выполнялся, но никакой последующий совместно используемый режим получают, может успешно выполниться; и положительное значение, если сбор в совместно используемом режиме успешно выполнялся и последующий совместно используемый режим, получает, мог бы также успешно выполниться, когда последующий поток ожидания должен проверить наличие. (Поддержка трех различных возвращаемых значений позволяет этому методу использоваться в контекстах, где получает только иногда действие исключительно.) На успех был получен этот объект.
    
    Броски:
    
    IllegalMonitorStateException - если получение поместило бы этот синхронизатор в недопустимое состояние. Это исключение должно быть выдано непротиворечивым способом для синхронизации, чтобы работать правильно.
    
    UnsupportedOperationException - если совместно использованный режим не поддерживается
  - tryReleaseShared
```
protected boolean tryReleaseShared(int arg)
```
    Попытки установить состояние, чтобы отразить выпуск в совместно используемом режиме.
    Этот метод всегда вызывается выпуском выполнения потока.
    Броски реализации по умолчанию UnsupportedOperationException.
    
    Параметры:
    arg - параметр выпуска. Это значение всегда является тем, которое передают к методу выпуска, или значение текущего состояния после записи в условие ожидает. Значение иначе неинтерпретируется и может представить что-либо, что Вы любите.
    
    Возвраты:
    true если этот выпуск совместно используемого режима может разрешить, чтобы ожидание получило (совместно использованный или монопольный), чтобы успешно выполниться; и false иначе
    
    Броски:
    
    IllegalMonitorStateException - если выпуск поместил бы этот синхронизатор в недопустимое состояние. Это исключение должно быть выдано непротиворечивым способом для синхронизации, чтобы работать правильно.
    
    UnsupportedOperationException - если совместно использованный режим не поддерживается
  - isHeldExclusively
```
protected boolean isHeldExclusively()
```
    Возвраты true если синхронизация считается исключительно относительно текущего (вызов) потоком. Этот метод вызывается на каждый звонок в неожидание AbstractQueuedSynchronizer.ConditionObject метод. (Ожидающие методы вместо этого вызывают release(int).)
    Броски реализации по умолчанию UnsupportedOperationException. Этот метод вызывается внутренне только в пределах AbstractQueuedSynchronizer.ConditionObject методы, так не должен быть определен, если условия не используются.
    
    Возвраты:
    true если синхронизация сохранена исключительно; false иначе
    
    Броски:
    
    UnsupportedOperationException - если условия не поддерживаются
  - получить
```
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 - если текущий поток прерывается
  - выпуск
```
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()
```
    Запросы, ожидают ли какие-либо потоки, чтобы получить. Отметьте это, потому что отмены из-за прерываний и тайм-аутов могут произойти в любое время, a true возврат не гарантирует, что любой другой поток будет когда-либо получать.
    В этой реализации эта работа возвращается в постоянное время.
    
    Возвраты:
    true если могут быть другие потоки, ожидающие, чтобы получить
  - hasContended
```
public final boolean hasContended()
```
    Запросы, спорили ли какие-либо потоки когда-либо, чтобы получить этот синхронизатор; это - то, если получать метод когда-либо блокировал.
    В этой реализации эта работа возвращается в постоянное время.
    
    Возвраты:
    true если когда-либо была конкуренция
  - getFirstQueuedThread
```
public final Thread getFirstQueuedThread()
```
    Возвращает первый (дольше всего ожидающий) поток в очереди, или null если никакие потоки в настоящий момент не ставятся в очередь.
    В этой реализации эта работа обычно возвращается в постоянное время, но может выполнить итерации на конкуренцию, если другие потоки одновременно изменяют очередь.
    
    Возвраты:
    первый (дольше всего ожидающий) поток в очереди, или null если никакие потоки в настоящий момент не ставятся в очередь
  - isQueued
```
public final boolean isQueued(Thread thread)
```
    Возвращает true, если данный поток в настоящий момент ставится в очередь.
    Эта реализация пересекает очередь, чтобы определить присутствие данного потока.
    
    Параметры:
    thread - поток
    
    Возвраты:
    true если данный поток находится на очереди
    
    Броски:
    
    NullPointerException - если поток является нулем
  - hasQueuedPredecessors
```
public final boolean hasQueuedPredecessors()
```
    Запросы, ожидали ли какие-либо потоки, чтобы получить дольше чем текущий поток.
    Вызов этого метода эквивалентен (но может быть более эффективным чем):
```
 getFirstQueuedThread() != Thread.currentThread() &&
 hasQueuedThreads()
```
    Отметьте это, потому что отмены из-за прерываний и тайм-аутов могут произойти в любое время, a true возврат не гарантирует, что некоторый другой поток получит перед текущим потоком. Аналогично, для другого потока возможно выиграть гонки, чтобы ставить в очередь после того, как этот метод возвратился false, из-за очереди, являющейся пустым.
    Этот метод разрабатывается, чтобы использоваться справедливым синхронизатором, чтобы избежать неуклюже передвигаться. Такой синхронизатор tryAcquire(int) метод должен возвратиться false, и tryAcquireShared(int) метод должен возвратить отрицательную величину, если этот метод возвращается true (если это не повторно используемое, получают). Например, tryAcquire метод для справедливого, повторно используемого, монопольного синхронизатора режима мог бы быть похожим на это:
```
 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
    
    Возвраты:
    строка, идентифицирующая этот синхронизатор, так же как его состояние
  - имеет
```
public final boolean owns(AbstractQueuedSynchronizer.ConditionObject condition)
```
    Запросы, использует ли данный ConditionObject этот синхронизатор в качестве своей блокировки.
    
    Параметры:
    condition - условие
    
    Возвраты:
    true если принадлежащийся
    
    Броски:
    
    NullPointerException - если условие является нулем
  - hasWaiters
```
public final boolean hasWaiters(AbstractQueuedSynchronizer.ConditionObject condition)
```
    Запросы, ожидают ли какие-либо потоки на данном условии, связанном с этим синхронизатором. Отметьте, что, потому что тайм-ауты и прерывания могут произойти в любое время, возврат true не гарантирует, что будущий signal пробудит любые потоки. Этот метод разрабатывается прежде всего для использования в контроле системного состояния.
    
    Параметры:
    condition - условие
    
    Возвраты:
    true, если есть какие-либо потоки ожидания
    
    Броски:
    
    IllegalMonitorStateException - если монопольная синхронизация не сохранена
    
    IllegalArgumentException - если данное условие не связывается с этим синхронизатором
    
    NullPointerException - если условие является нулем
  - getWaitQueueLength
```
public final int getWaitQueueLength(AbstractQueuedSynchronizer.ConditionObject condition)
```
    Возвращает оценку числа потоков, ожидающих на данном условии, связанном с этим синхронизатором. Отметьте, что, потому что тайм-ауты и прерывания могут произойти в любое время, оценка служит только в качестве верхней границы на фактическом числе официантов. Этот метод разрабатывается для использования в контроле системного состояния, не для управления синхронизацией.
    
    Параметры:
    condition - условие
    
    Возвраты:
    предполагаемое число потоков ожидания
    
    Броски:
    
    IllegalMonitorStateException - если монопольная синхронизация не сохранена
    
    IllegalArgumentException - если данное условие не связывается с этим синхронизатором
    
    NullPointerException - если условие является нулем
  - getWaitingThreads
```
public final Collection<Thread> getWaitingThreads(AbstractQueuedSynchronizer.ConditionObject condition)
```
    Возвращает набор, содержащий те потоки, которые могут ожидать на данном условии, связанном с этим синхронизатором. Поскольку фактический набор потоков может измениться динамически, создавая этот результат, возвращенный набор является только оценкой максимальных усилий. Элементы возвращенного набора без определенного порядка.
    
    Параметры:
    condition - условие
    
    Возвраты:
    набор потоков
    
    Броски:
    
    IllegalMonitorStateException - если монопольная синхронизация не сохранена
    
    IllegalArgumentException - если данное условие не связывается с этим синхронизатором
    
    NullPointerException - если условие является нулем

Представьте ошибку или функцию
Для дальнейшей ссылки API и документации разработчика, см. Java Документация SE. Та документация содержит более подробные, предназначенные разработчиком описания, с концептуальными краткими обзорами, определениями сроков, обходных решений, и рабочих примеров кода.
Авторское право © 1993, 2011, Oracle и/или его филиалы. Все права защищены.

Класс AbstractQueuedSynchronizer

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

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

Вложенная Сводка Класса

Сводка конструктора

Сводка метода

Методы, унаследованные от класса java.util.concurrent.locks.AbstractOwnableSynchronizer

Методы java.lang унаследованный от класса. Объект

Деталь конструктора

AbstractQueuedSynchronizer

Деталь метода

getState

setState

compareAndSetState

tryAcquire

tryRelease

tryAcquireShared

tryReleaseShared

isHeldExclusively

получить

acquireInterruptibly

tryAcquireNanos

выпуск

acquireShared

acquireSharedInterruptibly

tryAcquireSharedNanos

releaseShared

hasQueuedThreads

hasContended

getFirstQueuedThread

isQueued

hasQueuedPredecessors

getQueueLength

getQueuedThreads

getExclusiveQueuedThreads

getSharedQueuedThreads

toString

имеет

hasWaiters

getWaitQueueLength

getWaitingThreads