AbstractQueuedSynchronizer Класс

Определение

Пространство имен:: Java.Util.Concurrent.Locks

Сборка:: Mono.Android.dll

Важно!

Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.

[Android.Runtime.Register("java/util/concurrent/locks/AbstractQueuedSynchronizer", DoNotGenerateAcw=true)]
public abstract class AbstractQueuedSynchronizer : Java.Util.Concurrent.Locks.AbstractOwnableSynchronizer, IDisposable

[<Android.Runtime.Register("java/util/concurrent/locks/AbstractQueuedSynchronizer", DoNotGenerateAcw=true)>]
type AbstractQueuedSynchronizer = class
    inherit AbstractOwnableSynchronizer
    interface ISerializable
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable

Наследование: Object

JavaObject

Object

AbstractOwnableSynchronizer
AbstractQueuedSynchronizer

Атрибуты: RegisterAttribute

Реализации: IJavaObject IJavaPeerable ISerializable IDisposable

Предоставляет платформу для реализации блокирующих блокировок и связанных синхронизаторов (семафоры, события и т. д.), основанных на очередях ожидания первого выхода (FIFO). Этот класс предназначен для использования большинства типов синхронизаторов, использующих одно атомарное int значение для представления состояния. Подклассы должны определять защищенные методы, изменяющие это состояние, и определить, что такое состояние означает с точки зрения получения или выпуска этого объекта. Учитывая это, другие методы в этом классе выполняют все механизмы очереди и блокировки. Подклассы могут поддерживать другие поля состояния, но только атомарны обновленные int значения, управляемые с помощью методов #getState, #setState и #compareAndSetState отслеживаются в отношении синхронизации.

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

Этот класс поддерживает режим em эксклюзив/em по умолчанию <>и <режим em>shared</em>.<> При получении в монопольном режиме попытки получения другими потоками не могут завершиться успешно. Общий режим получается несколькими потоками (но не требуется). Этот класс не " понимание" эти различия за исключением того, что при успешном получении общего режима следующий поток ожидания (если существует) также должен определить, может ли он также получить. Потоки, ожидающие в разных режимах, используют одну очередь FIFO. Как правило, подклассы реализации поддерживают только один из этих режимов, но оба могут играть, например в .ReadWriteLock Подклассы, поддерживающие только эксклюзивные или только общие режимы, не должны определять методы, поддерживающие неиспользуемый режим.

Этот класс определяет вложенный класс, который можно использовать в качестве ConditionObject реализации подклассами, поддерживающими монопольный режим, для которого метод сообщает, является ли синхронизация исключительно удерживаемой в отношении текущего потока, метод Condition#isHeldExclusively, вызываемый #release#getState текущим значением, полностью освобождает этот объект и#acquire, учитывая это сохраненное значение состояния, в конечном итоге восстанавливает этот объект до предыдущего полученного состояния. Метод не AbstractQueuedSynchronizer создает такое условие, поэтому если это ограничение не может быть выполнено, не используйте его. Поведение ConditionObject зависит от семантики реализации синхронизатора.

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

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

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

<ul><li>#tryAcquire<li>#tryRelease<li>#tryAcquireShared<li li li>#tryReleaseShared</ul>#isHeldExclusively<>

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

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

Несмотря на то что этот класс основан на внутренней очереди FIFO, он не применяет политики приобретения FIFO автоматически. Ядро эксклюзивной синхронизации принимает форму:

<em>Acquire:</em>
                while (!tryAcquire(arg)) {
<em>enqueue thread if it is not already queued</em>;
<em>possibly block current thread</em>;
                }

<em>Release:</em>
                if (tryRelease(arg))
<em>unblock the first queued thread</em>;

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

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

Пропускная способность и масштабируемость, как правило, являются самыми высокими для стратегии баржирования по умолчанию (также известной как <em жадность>/<em, ><отказ в>< em и>< em конво-избегание>/em<).> Хотя это не гарантируется справедливым или свободным от голода, более ранние очереди потоков разрешены для повторного восстановления до последующих очередей потоков, и каждая повторная сборка имеет неустранимый шанс добиться успеха в отношении входящих потоков. Кроме того, при приобретении не " spin" в обычном смысле они могут выполнять несколько вызовов tryAcquire перемежаемых с другими вычислениями перед блокировкой. Это дает большую часть преимуществ спинов, когда монопольная синхронизация проводится только кратко, без большинства обязательств, когда это не так. Если это необходимо, вы можете расширить это путем предыдущих вызовов для получения методов с проверками быстрого пути, возможно, предварительной проверки #hasContended и /или #hasQueuedThreads сделать это только в том случае, если синхронизатор, скорее всего, не будет оспариваться.

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

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

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

{@code
            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));
              }
            }}

Вот класс блокировки, который похож java.util.concurrent.CountDownLatch CountDownLatch на то, что он требует только одного signal для пожара. Так как блокировка не является монопольной, она использует shared методы получения и выпуска.

{@code
            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.

Java документации по java.util.concurrent.locks.AbstractQueuedSynchronizer.

Части этой страницы — это изменения на основе работы, созданной и общей Project и используемых в соответствии с условиями, описанными в разделе "".

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

Имя	Описание
AbstractQueuedSynchronizer()	Создает новый `AbstractQueuedSynchronizer` экземпляр с начальным состоянием синхронизации нулевого значения.
AbstractQueuedSynchronizer(IntPtr, JniHandleOwnership)	Конструктор, используемый при создании управляемых представлений объектов JNI; вызывается средой выполнения.

Свойства

Имя	Описание
Class	Возвращает класс среды выполнения этого `Object`объекта. (Унаследовано от Object)
ExclusiveOwnerThread	Возвращает последний набор потока или`setExclusiveOwnerThreadnull`, если никогда не задан. -или- Задает поток, который в настоящее время владеет монопольным доступом. (Унаследовано от AbstractOwnableSynchronizer)
ExclusiveQueuedThreads	Возвращает коллекцию, содержащую потоки, которые могут ожидать получения в монопольном режиме.
FirstQueuedThread	Возвращает первый (самый длинный) поток в очереди или `null` если потоки в настоящее время не находятся в очереди.
Handle	Дескриптор базового экземпляра Android. (Унаследовано от Object)
HasContended	Запрашивает, какие потоки когда-либо утверждали, чтобы получить этот синхронизатор; То есть, если метод получения когда-либо заблокирован.
HasQueuedPredecessors	Запросы, ожидающие получения потока дольше текущего потока.
HasQueuedThreads	Запрашивает, ожидают ли какие-либо потоки получения.
IsHeldExclusively	Возвращает, `true` если синхронизация проводится исключительно в отношении текущего (вызывающего) потока.
JniIdentityHashCode	Возвращает хэш-код удостоверения, назначенный этому Java одноранговой среде выполнения взаимодействия. (Унаследовано от Object)
JniManagedPeerState	Предоставляет платформу для реализации блокирующих блокировок и связанных синхронизаторов (семафоры, события и т. д.), основанных на очередях ожидания первого выхода (FIFO). (Унаследовано от JavaObject)
JniPeerMembers	Возвращает метаданные JNI, используемые для вызова элементов этого Java однорангового узла.
PeerReference	Возвращает ссылку на объект JNI для этого Java однорангового узла. (Унаследовано от Object)
QueuedThreads	Возвращает коллекцию, содержащую потоки, которые могут ожидать получения.
QueueLength	Возвращает оценку количества потоков, ожидающих получения.
SharedQueuedThreads	Возвращает коллекцию, содержащую потоки, которые могут ожидать получения в общем режиме.
State	Возвращает текущее значение состояния синхронизации. -или- задает значение состояния синхронизации.
ThresholdClass	Этот API поддерживает инфраструктуру Mono для Android и не предназначен для использования непосредственно из кода.
ThresholdType	Этот API поддерживает инфраструктуру Mono для Android и не предназначен для использования непосредственно из кода.

Методы

Имя	Описание
Acquire(Int32)	Получает в монопольном режиме, игнорируя прерывания.
AcquireInterruptibly(Int32)	Получает в монопольном режиме прерывание при прерывании.
AcquireShared(Int32)	Получает в общем режиме, игнорируя прерывания.
AcquireSharedInterruptibly(Int32)	Получает общий режим, прерванный при прерывании.
Clone()	Создает и возвращает копию этого объекта. (Унаследовано от Object)
CompareAndSetState(Int32, Int32)	Атомарно задает состояние синхронизации заданному обновленному значению, если текущее значение состояния равно ожидаемому значению.
Construct(JniObjectReference, JniObjectReferenceOptions)	Предоставляет платформу для реализации блокирующих блокировок и связанных синхронизаторов (семафоры, события и т. д.), основанных на очередях ожидания первого выхода (FIFO). (Унаследовано от JavaObject)
Dispose()	Освобождает ресурсы, удерживаемые этим Java одноранговым узлом. (Унаследовано от Object)
Dispose(Boolean)	Освобождает ресурсы, удерживаемые этим Java одноранговым узлом. (Унаследовано от Object)
DisposeUnlessReferenced()	Предоставляет платформу для реализации блокирующих блокировок и связанных синхронизаторов (семафоры, события и т. д.), основанных на очередях ожидания первого выхода (FIFO). (Унаследовано от JavaObject)
Equals(Object)	Предоставляет платформу для реализации блокирующих блокировок и связанных синхронизаторов (семафоры, события и т. д.), основанных на очередях ожидания первого выхода (FIFO). (Унаследовано от JavaObject)
Equals(Object)	Указывает, равен ли другой объект этому объекту. (Унаследовано от Object)
GetHashCode()	Возвращает хэш-значение кода для объекта. (Унаследовано от Object)
GetWaitingThreads(AbstractQueuedSynchronizer+ConditionObject)	Возвращает коллекцию, содержащую те потоки, которые могут ожидать заданного условия, связанного с этим синхронизатором.
GetWaitQueueLength(AbstractQueuedSynchronizer+ConditionObject)	Возвращает оценку количества потоков, ожидающих заданного условия, связанного с этим синхронизатором.
HasWaiters(AbstractQueuedSynchronizer+ConditionObject)	Запрашивает, ожидают ли потоки заданного условия, связанного с этим синхронизатором.
IsQueued(Thread)	Возвращает значение true, если данный поток в настоящее время помещается в очередь.
JavaFinalize()	Вызывается сборщиком мусора в объекте, когда сборка мусора определяет, что больше ссылок на объект нет. (Унаследовано от Object)
Notify()	Просыпается один поток, ожидающий монитора этого объекта. (Унаследовано от Object)
NotifyAll()	Просыпает все потоки, ожидающие монитора этого объекта. (Унаследовано от Object)
Owns(AbstractQueuedSynchronizer+ConditionObject)	Запрашивает, использует ли данный параметр ConditionObject этот синхронизатор в качестве блокировки.
Release(Int32)	Выпуски в эксклюзивном режиме.
ReleaseShared(Int32)	Выпуски в общем режиме.
SetHandle(IntPtr, JniHandleOwnership)	Задает свойство Handle. (Унаследовано от Object)
SetPeerReference(JniObjectReference, JniObjectReferenceOptions)	Предоставляет платформу для реализации блокирующих блокировок и связанных синхронизаторов (семафоры, события и т. д.), основанных на очередях ожидания первого выхода (FIFO). (Унаследовано от JavaObject)
ToArray<T>()	Создает управляемый массив из этого Java оболочки массива. (Унаследовано от Object)
ToString()	Возвращает строковое представление объекта. (Унаследовано от Object)
TryAcquire(Int32)	Пытается приобрести в монопольном режиме.
TryAcquireNanos(Int32, Int64)	Пытается получить в монопольном режиме, прервать, если прервано, и завершиться ошибкой, если истекло заданное время ожидания.
TryAcquireShared(Int32)	Пытается получить в общем режиме.
TryAcquireSharedNanos(Int32, Int64)	Пытается приобрести в общем режиме, прервано, и завершается ошибкой, если истекает заданное время ожидания.
TryRelease(Int32)	Пытается задать состояние для отражения выпуска в монопольном режиме.
TryReleaseShared(Int32)	Пытается задать состояние для отражения выпуска в общем режиме.
UnregisterFromRuntime()	Отменяет регистрацию этого Java однорангового узла из среды выполнения взаимодействия. (Унаследовано от Object)
Wait()	Приводит к тому, что текущий поток будет ждать, пока он не проснется, как правило, путем <><уведомления/>em или <эм>прерванного</em.> (Унаследовано от Object)
Wait(Int64, Int32)	Приводит к тому, что текущий поток будет ждать, пока он не проснется, как правило, при <>получении уведомления</>em или <>эм прерваны< или> до тех пор, пока не истекло определенное количество реального времени. (Унаследовано от Object)
Wait(Int64)	Приводит к тому, что текущий поток будет ждать, пока он не проснется, как правило, при <>получении уведомления</>em или <>эм прерваны< или> до тех пор, пока не истекло определенное количество реального времени. (Унаследовано от Object)

Явные реализации интерфейса

Имя	Описание
IJavaPeerable.Disposed()	Предоставляет платформу для реализации блокирующих блокировок и связанных синхронизаторов (семафоры, события и т. д.), основанных на очередях ожидания первого выхода (FIFO). (Унаследовано от JavaObject)
IJavaPeerable.Finalized()	Предоставляет платформу для реализации блокирующих блокировок и связанных синхронизаторов (семафоры, события и т. д.), основанных на очередях ожидания первого выхода (FIFO). (Унаследовано от JavaObject)
IJavaPeerable.JniObjectReferenceControlBlock	Предоставляет платформу для реализации блокирующих блокировок и связанных синхронизаторов (семафоры, события и т. д.), основанных на очередях ожидания первого выхода (FIFO). (Унаследовано от JavaObject)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Предоставляет платформу для реализации блокирующих блокировок и связанных синхронизаторов (семафоры, события и т. д.), основанных на очередях ожидания первого выхода (FIFO). (Унаследовано от JavaObject)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Предоставляет платформу для реализации блокирующих блокировок и связанных синхронизаторов (семафоры, события и т. д.), основанных на очередях ожидания первого выхода (FIFO). (Унаследовано от JavaObject)
IJavaPeerable.SetPeerReference(JniObjectReference)	Предоставляет платформу для реализации блокирующих блокировок и связанных синхронизаторов (семафоры, события и т. д.), основанных на очередях ожидания первого выхода (FIFO). (Унаследовано от JavaObject)
IJavaPeerable.UnregisterFromRuntime()	Предоставляет платформу для реализации блокирующих блокировок и связанных синхронизаторов (семафоры, события и т. д.), основанных на очередях ожидания первого выхода (FIFO).

Методы расширения

Имя	Описание
GetJniTypeName(IJavaPeerable)	Возвращает имя JNI типа экземпляра `self`.
JavaAs<TResult>(IJavaPeerable)	Попробуйте принуждать к типу`self`, проверяя`TResult`, является ли приведение допустимым на стороне Java.
JavaCast<TResult>(IJavaObject)	Выполняет преобразование типа, проверяемого средой выполнения Android.
JavaCast<TResult>(IJavaObject)	Предоставляет платформу для реализации блокирующих блокировок и связанных синхронизаторов (семафоры, события и т. д.), основанных на очередях ожидания первого выхода (FIFO).
TryJavaCast<TResult>(IJavaPeerable, TResult)	Попробуйте принуждать к типу`self`, проверяя`TResult`, является ли приведение допустимым на стороне Java.

Применяется к