AbstractQueuedSynchronizer Clase
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Proporciona un marco para implementar bloqueos de bloqueo y sincronizadores relacionados (semáforos, eventos, etc.) que dependen de las colas de espera primero en salir (FIFO).
[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- Herencia
- Atributos
- Implementaciones
Comentarios
Proporciona un marco para implementar bloqueos de bloqueo y sincronizadores relacionados (semáforos, eventos, etc.) que dependen de las colas de espera primero en salir (FIFO). Esta clase está diseñada para ser una base útil para la mayoría de los tipos de sincronizadores que dependen de un único valor atómico int para representar el estado. Las subclases deben definir los métodos protegidos que cambian este estado y qué significa ese estado en términos de que este objeto se adquiere o libera. Dados estos, los demás métodos de esta clase llevan a cabo todos los mecanismos de puesta en cola y bloqueo. Las subclases pueden mantener otros campos de estado, pero solo el valor actualizado int atómicamente manipulado mediante métodos #getStatey #setState#compareAndSetState se realiza un seguimiento con respecto a la sincronización.
Las subclases deben definirse como clases auxiliares internas no públicas que se usan para implementar las propiedades de sincronización de su clase envolvente. La clase AbstractQueuedSynchronizer no implementa ninguna interfaz de sincronización. En su lugar, define métodos como #acquireInterruptibly que se pueden invocar según corresponda mediante bloqueos concretos y sincronizadores relacionados para implementar sus métodos públicos.
Esta clase admite o un modo em exclusivo/em< predeterminado >y un <modo em>compartido</em>.<> Cuando se adquiere en modo exclusivo, los intentos adquiridos por otros subprocesos no se pueden realizar correctamente. El modo compartido adquiere por varios subprocesos puede (pero no es necesario) realizar correctamente. Esta clase no " comprender" estas diferencias excepto en el sentido mecánico de que cuando un modo compartido adquiere correctamente, el siguiente subproceso en espera (si existe) también debe determinar si también puede adquirir. Los subprocesos que esperan en los distintos modos comparten la misma cola fiFO. Normalmente, las subclases de implementación solo admiten uno de estos modos, pero ambos pueden entrar en juego por ejemplo en un ReadWriteLock. Las subclases que solo admiten modos exclusivos o compartidos no necesitan definir los métodos que admiten el modo no se usa.
Esta clase define una clase anidada ConditionObject que se puede usar como implementación Condition por subclases que admiten el modo exclusivo para el que el método #isHeldExclusively informa de si la sincronización se mantiene exclusivamente con respecto al subproceso actual, el método #release invocado con el valor actual #getState libera completamente este objeto y #acquire, dado este valor de estado guardado, restaura finalmente este objeto a su estado adquirido anterior. De lo contrario, ningún AbstractQueuedSynchronizer método crea dicha condición, por lo que si no se puede cumplir esta restricción, no la use. El comportamiento de ConditionObject depende, por supuesto, de la semántica de su implementación del sincronizador.
Esta clase proporciona métodos de inspección, instrumentación y supervisión para la cola interna, así como métodos similares para objetos de condición. Estos se pueden exportar según sea necesario en las clases mediante para AbstractQueuedSynchronizer sus mecánicas de sincronización.
La serialización de esta clase almacena solo el estado de mantenimiento del entero atómico subyacente, por lo que los objetos deserializados tienen colas de subprocesos vacías. Las subclases típicas que requieren serialización definirán un readObject método que restaure esto a un estado inicial conocido tras la deserialización.
<h2>Usage</h2>
Para usar esta clase como base de un sincronizador, vuelva a definir los métodos siguientes, según corresponda, inspeccionando o modificando el estado de sincronización mediante #getState, #setState o #compareAndSetState:
<ul>li li<>#tryAcquire<>#tryReleaseli<>#tryAcquireSharedli li<>#tryReleaseSharedli<>#isHeldExclusively/ul<>
Cada uno de estos métodos UnsupportedOperationExceptioninicia de forma predeterminada . Las implementaciones de estos métodos deben ser seguras para subprocesos internamente y, en general, deben ser cortas y no bloquearse. Definir estos métodos es los <medios admitidos de em>only</em> de usar esta clase. Todos los demás métodos se declaran final porque no pueden variar de forma independiente.
También puede encontrar los métodos heredados de AbstractOwnableSynchronizer útiles para realizar un seguimiento del subproceso que posee un sincronizador exclusivo. Se recomienda usarlos: esto permite la supervisión y las herramientas de diagnóstico para ayudar a los usuarios a determinar qué subprocesos contienen bloqueos.
Aunque esta clase se basa en una cola FIFO interna, no aplica automáticamente las directivas de adquisición de FIFO. El núcleo de la sincronización exclusiva tiene la forma de:
<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>;
(El modo compartido es similar, pero puede implicar señales en cascada).
Dado que las comprobaciones de adquisición se invocan antes de poner en cola, un subproceso recién adquirido puede <em barge></em> por delante de otros que están bloqueados y en cola. Sin embargo, puede, si lo desea, definir tryAcquire o tryAcquireShared deshabilitar la barraging invocando internamente uno o varios de los métodos de inspección, proporcionando así un<> pedido de adquisición em fair</em> FIFO. En concreto, la mayoría de los sincronizadores justos pueden definir tryAcquire para devolver false si #hasQueuedPredecessors (un método diseñado específicamente para ser utilizado por sincronizadores justos) devuelve true. Otras variaciones son posibles.
El rendimiento y la escalabilidad suelen ser más altos para la estrategia predeterminada de barging (también conocida como <em expansión>/em<, ><renuncia/>em<) y >em<convoy-evitación>/em<>). Aunque esto no se garantiza que sea justo o sin hambre, se permite que los subprocesos en cola anteriores se recontendrán antes de que los subprocesos en cola posteriores y cada recontención tenga una oportunidad no sesgada de tener éxito en los subprocesos entrantes. Además, mientras adquieres no " spin" en el sentido habitual, pueden realizar varias invocaciones de intercalaciones con otros cálculos antes de tryAcquire bloquear. Esto proporciona la mayoría de las ventajas de los giros cuando la sincronización exclusiva solo se mantiene brevemente, sin la mayor parte de los pasivos cuando no lo es. Si lo desea, puede aumentar esto mediante llamadas anteriores para adquirir métodos con comprobaciones de "ruta de acceso rápida", posiblemente la comprobación #hasContended previa o #hasQueuedThreads solo para hacerlo si es probable que el sincronizador no esté contendido.
Esta clase proporciona una base eficaz y escalable para la sincronización en parte especializando su intervalo de uso para los sincronizadores que pueden confiar en int los parámetros de estado, adquisición y versión, y una cola de espera de FIFO interna. Cuando esto no es suficiente, puede crear sincronizadores desde un nivel inferior mediante java.util.concurrent.atomic atomic clases, clases personalizadas java.util.Queue propias y LockSupport compatibilidad con bloqueos.
<h2>Ejemplos< de uso/h2>
Esta es una clase de bloqueo de exclusión mutua no reentrante que usa el valor cero para representar el estado desbloqueado y otro para representar el estado bloqueado. Aunque un bloqueo no reentrante no requiere estrictamente la grabación del subproceso propietario actual, esta clase lo hace de todos modos para facilitar el uso de la supervisión. También admite condiciones y expone algunos métodos de instrumentación:
{@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));
}
}}
Esta es una clase de bloqueo temporal similar a una java.util.concurrent.CountDownLatch CountDownLatch excepción de que solo requiere un solo signal para activarse. Dado que un bloqueo temporal no es exclusivo, usa los shared métodos acquire y release.
{@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);
}
}}
Agregado en 1.5.
Documentación de Java para java.util.concurrent.locks.AbstractQueuedSynchronizer.
Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el proyecto de código abierto de Android y se usan según los términos descritos en la licencia de atribución de Creative Commons 2.5.
Constructores
| Nombre | Description |
|---|---|
| AbstractQueuedSynchronizer() |
Crea una nueva |
| AbstractQueuedSynchronizer(IntPtr, JniHandleOwnership) |
Constructor utilizado al crear representaciones administradas de objetos JNI; llamado por el tiempo de ejecución. |
Propiedades
| Nombre | Description |
|---|---|
| Class |
Devuelve la clase en tiempo de ejecución de este |
| ExclusiveOwnerThread |
Devuelve el último subproceso establecido por |
| ExclusiveQueuedThreads |
Devuelve una colección que contiene subprocesos que pueden estar esperando adquirirse en modo exclusivo. |
| FirstQueuedThread |
Devuelve el primer subproceso (en espera más largo) de la cola o |
| Handle |
Identificador de la instancia de Android subyacente. (Heredado de Object) |
| HasContended |
Consulta si algún subproceso ha tenido que adquirir este sincronizador; es decir, si un método de adquisición ha bloqueado alguna vez. |
| HasQueuedPredecessors |
Consulta si algún subproceso ha estado esperando adquirir más tiempo que el subproceso actual. |
| HasQueuedThreads |
Consulta si algún subproceso está esperando adquirir. |
| IsHeldExclusively |
Devuelve |
| JniIdentityHashCode |
Obtiene el código hash de identidad asignado a este Java del mismo nivel por el tiempo de ejecución de interoperabilidad. (Heredado de Object) |
| JniManagedPeerState |
Proporciona un marco para implementar bloqueos de bloqueo y sincronizadores relacionados (semáforos, eventos, etc.) que dependen de las colas de espera primero en salir (FIFO). (Heredado de JavaObject) |
| JniPeerMembers |
Obtiene los metadatos de JNI usados para invocar miembros de este Java del mismo nivel. |
| PeerReference |
Obtiene la referencia de objeto JNI para este Java del mismo nivel. (Heredado de Object) |
| QueuedThreads |
Devuelve una colección que contiene subprocesos que pueden estar esperando adquirir. |
| QueueLength |
Devuelve una estimación del número de subprocesos a la espera de adquirir. |
| SharedQueuedThreads |
Devuelve una colección que contiene subprocesos que pueden estar esperando adquirir en modo compartido. |
| State |
Devuelve el valor actual del estado de sincronización. -o bien- Establece el valor del estado de sincronización. |
| ThresholdClass |
Esta API admite la infraestructura mono para Android y no está pensada para usarse directamente desde el código. |
| ThresholdType |
Esta API admite la infraestructura mono para Android y no está pensada para usarse directamente desde el código. |
Métodos
| Nombre | Description |
|---|---|
| Acquire(Int32) |
Adquiere en modo exclusivo, ignorando las interrupciones. |
| AcquireInterruptibly(Int32) |
Adquiere en modo exclusivo, anulando si se interrumpe. |
| AcquireShared(Int32) |
Adquiere en modo compartido, ignorando las interrupciones. |
| AcquireSharedInterruptibly(Int32) |
Adquiere en modo compartido, anulando si se interrumpe. |
| Clone() |
Crea y devuelve una copia de este objeto. (Heredado de Object) |
| CompareAndSetState(Int32, Int32) |
Establece de forma atómica el estado de sincronización en el valor actualizado especificado si el valor de estado actual es igual al valor esperado. |
| Construct(JniObjectReference, JniObjectReferenceOptions) |
Proporciona un marco para implementar bloqueos de bloqueo y sincronizadores relacionados (semáforos, eventos, etc.) que dependen de las colas de espera primero en salir (FIFO). (Heredado de JavaObject) |
| Dispose() |
Libera los recursos mantenidos por este Java del mismo nivel. (Heredado de Object) |
| Dispose(Boolean) |
Libera los recursos mantenidos por este Java del mismo nivel. (Heredado de Object) |
| DisposeUnlessReferenced() |
Proporciona un marco para implementar bloqueos de bloqueo y sincronizadores relacionados (semáforos, eventos, etc.) que dependen de las colas de espera primero en salir (FIFO). (Heredado de JavaObject) |
| Equals(Object) |
Proporciona un marco para implementar bloqueos de bloqueo y sincronizadores relacionados (semáforos, eventos, etc.) que dependen de las colas de espera primero en salir (FIFO). (Heredado de JavaObject) |
| Equals(Object) |
Indica si algún otro objeto es "igual a" este. (Heredado de Object) |
| GetHashCode() |
Devuelve un valor de código hash para el objeto . (Heredado de Object) |
| GetWaitingThreads(AbstractQueuedSynchronizer+ConditionObject) |
Devuelve una colección que contiene esos subprocesos que pueden estar esperando la condición dada asociada a este sincronizador. |
| GetWaitQueueLength(AbstractQueuedSynchronizer+ConditionObject) |
Devuelve una estimación del número de subprocesos en espera de la condición dada asociada a este sincronizador. |
| HasWaiters(AbstractQueuedSynchronizer+ConditionObject) |
Consulta si algún subproceso está esperando la condición dada asociada a este sincronizador. |
| IsQueued(Thread) |
Devuelve true si el subproceso especificado está actualmente en cola. |
| JavaFinalize() |
Lo llama el recolector de elementos no utilizados en un objeto cuando la recolección de elementos no utilizados determina que no hay más referencias al objeto . (Heredado de Object) |
| Notify() |
Activa un único subproceso que está esperando en el monitor de este objeto. (Heredado de Object) |
| NotifyAll() |
Activa todos los subprocesos que están esperando en el monitor de este objeto. (Heredado de Object) |
| Owns(AbstractQueuedSynchronizer+ConditionObject) |
Consulta si conditionObject especificado usa este sincronizador como bloqueo. |
| Release(Int32) |
Libera en modo exclusivo. |
| ReleaseShared(Int32) |
Libera en modo compartido. |
| SetHandle(IntPtr, JniHandleOwnership) |
Establece la propiedad Handle. (Heredado de Object) |
| SetPeerReference(JniObjectReference, JniObjectReferenceOptions) |
Proporciona un marco para implementar bloqueos de bloqueo y sincronizadores relacionados (semáforos, eventos, etc.) que dependen de las colas de espera primero en salir (FIFO). (Heredado de JavaObject) |
| ToArray<T>() |
Crea una matriz administrada a partir de este contenedor de matriz Java. (Heredado de Object) |
| ToString() |
Devuelve una representación de cadena del objeto . (Heredado de Object) |
| TryAcquire(Int32) |
Intenta adquirir en modo exclusivo. |
| TryAcquireNanos(Int32, Int64) |
Intenta adquirir en modo exclusivo, anulando si se interrumpe y produce un error si transcurre el tiempo de espera especificado. |
| TryAcquireShared(Int32) |
Intenta adquirir en modo compartido. |
| TryAcquireSharedNanos(Int32, Int64) |
Intenta adquirir en modo compartido, anulando si se interrumpe y produce un error si transcurre el tiempo de espera especificado. |
| TryRelease(Int32) |
Intenta establecer el estado para reflejar una versión en modo exclusivo. |
| TryReleaseShared(Int32) |
Intenta establecer el estado para reflejar una versión en modo compartido. |
| UnregisterFromRuntime() |
Anula el registro de este Java del mismo nivel del tiempo de ejecución de interoperabilidad. (Heredado de Object) |
| Wait() |
Hace que el subproceso actual espere hasta que se despierte, normalmente por ser em notificado/em< o >em<interrumpido>/em<.><> (Heredado de Object) |
| Wait(Int64, Int32) |
Hace que el subproceso actual espere hasta que se despierte, normalmente por ser <em>notificado</em> o <em>interrumpido</em>, o hasta que haya transcurrido una cierta cantidad de tiempo real. (Heredado de Object) |
| Wait(Int64) |
Hace que el subproceso actual espere hasta que se despierte, normalmente por ser <em>notificado</em> o <em>interrumpido</em>, o hasta que haya transcurrido una cierta cantidad de tiempo real. (Heredado de Object) |
Implementaciones de interfaz explícitas
| Nombre | Description |
|---|---|
| IJavaPeerable.Disposed() |
Proporciona un marco para implementar bloqueos de bloqueo y sincronizadores relacionados (semáforos, eventos, etc.) que dependen de las colas de espera primero en salir (FIFO). (Heredado de JavaObject) |
| IJavaPeerable.Finalized() |
Proporciona un marco para implementar bloqueos de bloqueo y sincronizadores relacionados (semáforos, eventos, etc.) que dependen de las colas de espera primero en salir (FIFO). (Heredado de JavaObject) |
| IJavaPeerable.JniObjectReferenceControlBlock |
Proporciona un marco para implementar bloqueos de bloqueo y sincronizadores relacionados (semáforos, eventos, etc.) que dependen de las colas de espera primero en salir (FIFO). (Heredado de JavaObject) |
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
Proporciona un marco para implementar bloqueos de bloqueo y sincronizadores relacionados (semáforos, eventos, etc.) que dependen de las colas de espera primero en salir (FIFO). (Heredado de JavaObject) |
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
Proporciona un marco para implementar bloqueos de bloqueo y sincronizadores relacionados (semáforos, eventos, etc.) que dependen de las colas de espera primero en salir (FIFO). (Heredado de JavaObject) |
| IJavaPeerable.SetPeerReference(JniObjectReference) |
Proporciona un marco para implementar bloqueos de bloqueo y sincronizadores relacionados (semáforos, eventos, etc.) que dependen de las colas de espera primero en salir (FIFO). (Heredado de JavaObject) |
| IJavaPeerable.UnregisterFromRuntime() |
Proporciona un marco para implementar bloqueos de bloqueo y sincronizadores relacionados (semáforos, eventos, etc.) que dependen de las colas de espera primero en salir (FIFO). |
Métodos de extensión
| Nombre | Description |
|---|---|
| GetJniTypeName(IJavaPeerable) |
Obtiene el nombre JNI del tipo de la instancia |
| JavaAs<TResult>(IJavaPeerable) |
Intente coerción |
| JavaCast<TResult>(IJavaObject) |
Realiza una conversión de tipos comprobados en tiempo de ejecución de Android. |
| JavaCast<TResult>(IJavaObject) |
Proporciona un marco para implementar bloqueos de bloqueo y sincronizadores relacionados (semáforos, eventos, etc.) que dependen de las colas de espera primero en salir (FIFO). |
| TryJavaCast<TResult>(IJavaPeerable, TResult) |
Intente coerción |