AbstractQueuedSynchronizer Classe
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Fornisce un framework per implementare blocchi di blocco e sincronizzatori correlati (semafori, eventi e così via) che si basano su code di attesa FIFO (First-In-First Out).
[Android.Runtime.Register("java/util/concurrent/locks/AbstractQueuedSynchronizer", DoNotGenerateAcw=true)]
public abstract class AbstractQueuedSynchronizer : Java.Util.Concurrent.Locks.AbstractOwnableSynchronizer, IDisposable, Java.Interop.IJavaPeerable[<Android.Runtime.Register("java/util/concurrent/locks/AbstractQueuedSynchronizer", DoNotGenerateAcw=true)>]
type AbstractQueuedSynchronizer = class
inherit AbstractOwnableSynchronizer
interface ISerializable
interface IJavaObject
interface IDisposable
interface IJavaPeerable- Ereditarietà
- Attributi
- Implementazioni
Commenti
Fornisce un framework per implementare blocchi di blocco e sincronizzatori correlati (semafori, eventi e così via) che si basano su code di attesa FIFO (First-In-First Out). Questa classe è progettata per essere una base utile per la maggior parte dei tipi di sincronizzatori che si basano su un singolo valore atomico int per rappresentare lo stato. Le sottoclassi devono definire i metodi protetti che modificano questo stato e che definiscono il significato di tale stato in termini di acquisizione o rilascio di questo oggetto. Considerati questi, gli altri metodi in questa classe eseguono tutte le operazioni di accodamento e meccanismi di blocco. Le sottoclassi possono mantenere altri campi di stato, ma solo il valore aggiornato int atomicamente modificato usando i metodi #getState#setState e #compareAndSetState viene rilevato in relazione alla sincronizzazione.
Le sottoclassi devono essere definite come classi helper interne non pubbliche usate per implementare le proprietà di sincronizzazione della classe contenitore. La classe AbstractQueuedSynchronizer non implementa alcuna interfaccia di sincronizzazione. Definisce invece metodi come #acquireInterruptibly che possono essere richiamati in base alle esigenze da blocchi concreti e sincronizzatori correlati per implementare i relativi metodi pubblici.
Questa classe supporta o sia una modalità em exclusive/em predefinita <>che una <modalità em>shared</em>.>< Se acquisito in modalità esclusiva, i tentativi acquisiti da altri thread non possono avere esito positivo. La modalità condivisa acquisisce da più thread può (ma non è necessario) avere esito positivo. Questa classe non " comprendere " queste differenze tranne nel senso meccanico che quando una modalità condivisa acquisisce ha esito positivo, il thread in attesa successivo (se esistente) deve anche determinare se può anche acquisire. I thread in attesa nelle diverse modalità condividono la stessa coda FIFO. In genere, le sottoclassi di implementazione supportano solo una di queste modalità, ma entrambi possono entrare in gioco, ad esempio in un oggetto ReadWriteLock. Le sottoclassi che supportano solo le modalità esclusive o condivise non devono definire i metodi che supportano la modalità inutilizzata.
Questa classe definisce una classe annidata che può essere utilizzata come Condition implementazione da sottoclassi che supportano la modalità esclusiva per cui il metodo #isHeldExclusively segnala se la sincronizzazione viene mantenuta esclusivamente rispetto al thread corrente, il metodo #release richiamato ConditionObject con il valore corrente #getState rilascia completamente questo oggetto e #acquire, dato questo valore di stato salvato, ripristina infine questo oggetto allo stato acquisito precedente. In caso contrario, nessun AbstractQueuedSynchronizer metodo crea una condizione di questo tipo, quindi se questo vincolo non può essere soddisfatto, non usarlo. Il comportamento di ConditionObject dipende naturalmente dalla semantica dell'implementazione del programma di sincronizzazione.
Questa classe fornisce metodi di ispezione, strumentazione e monitoraggio per la coda interna, nonché metodi simili per gli oggetti condizione. Questi possono essere esportati come desiderato nelle classi usando un AbstractQueuedSynchronizer oggetto per i meccanismi di sincronizzazione.
La serializzazione di questa classe archivia solo l'intero atomico sottostante che mantiene lo stato, quindi gli oggetti deserializzati hanno code di thread vuote. Le sottoclassi tipiche che richiedono la serializzabilità definiranno un readObject metodo che lo ripristina in uno stato iniziale noto al momento della deserializzazione.
<h2>Usage</h2>
Per usare questa classe come base di un programma di sincronizzazione, ridefinire i metodi seguenti, come applicabile, esaminando e/o modificando lo stato di sincronizzazione tramite #getStatee #setState /o #compareAndSetState:
<ul><li><#tryAcquireli><#tryReleaseli li><#tryAcquireSharedli><>#tryReleaseShared<#isHeldExclusively/ul>
Ognuno di questi metodi per impostazione predefinita genera UnsupportedOperationException. Le implementazioni di questi metodi devono essere internamente thread-safe e in generale devono essere brevi e non bloccate. La definizione di questi metodi è il mezzo supportato solo</em> per l'uso <>di questa classe. Tutti gli altri metodi vengono dichiarati final perché non possono essere diversi in modo indipendente.
È anche possibile trovare i metodi ereditati da AbstractOwnableSynchronizer utile per tenere traccia del thread proprietario di un programma di sincronizzazione esclusivo. È consigliabile usarli. Ciò consente di monitorare e strumenti di diagnostica per aiutare gli utenti a determinare quali thread contengono blocchi.
Anche se questa classe è basata su una coda FIFO interna, non applica automaticamente i criteri di acquisizione FIFO. Il nucleo della sincronizzazione esclusiva assume il formato:
<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>;
La modalità condivisa è simile, ma può comportare segnali a catena.
Poiché i controlli in acquisizione vengono richiamati prima dell'accodamento, un nuovo thread di acquisizione potrebbe <essere><> in attesa di altri che sono bloccati e accodati. Tuttavia, è possibile, se necessario, definire tryAcquire e/o tryAcquireShared disabilitare il barging richiamando internamente uno o più metodi di ispezione, fornendo così un <>ordine di acquisizione FIFO equo</em>. In particolare, la maggior parte dei programma di sincronizzazione fair può definire tryAcquire per restituire false se #hasQueuedPredecessors (un metodo progettato appositamente per essere usato dai programmatori di sincronizzazione faire) restituisce true. Sono possibili altre varianti.
La velocità effettiva e la scalabilità sono in genere più elevate per la strategia predefinita di barging (nota anche come <em>greedy</em>, <em>rinunci/<em> e <em>e evitare</em>). Anche se questo non è garantito che sia equo o privo di fame, i thread in coda precedenti sono autorizzati a ricostituire prima dei thread in coda successivi e ogni ricontento ha la possibilità di avere esito negativo rispetto ai thread in ingresso. Inoltre, mentre acquisizioni non " spin" nel senso consueto, possono eseguire più chiamate di tryAcquire intersperse con altri calcoli prima del blocco. Ciò offre la maggior parte dei vantaggi delle rotazioni quando la sincronizzazione esclusiva viene mantenuta solo brevemente, senza la maggior parte delle responsabilità quando non lo è. Se lo si desidera, è possibile aumentare questa funzionalità con le chiamate precedenti per acquisire i metodi con controlli "fast-path", eventualmente precontrollando #hasContended e/o #hasQueuedThreads solo in caso contrario, se è probabile che il programma di sincronizzazione non sia in grado di essere conteso.
Questa classe fornisce una base efficiente e scalabile per la sincronizzazione in parte specializzata nella sua gamma di usi per sincronizzare che possono basarsi su int parametri di stato, acquisizione e rilascio e una coda di attesa FIFO interna. Quando ciò non è sufficiente, è possibile creare programmatori di sincronizzazione da un livello inferiore usando java.util.concurrent.atomic atomic classi, classi personalizzate java.util.Queue e LockSupport supporto di blocco.
<Esempi< di utilizzo h2>/h2>
Ecco una classe di blocco di esclusione reciproca non reentrant che usa il valore zero per rappresentare lo stato sbloccato e una per rappresentare lo stato bloccato. Anche se un blocco non reentrant non richiede rigorosamente la registrazione del thread proprietario corrente, questa classe lo fa comunque per semplificare il monitoraggio dell'utilizzo. Supporta anche le condizioni ed espone alcuni metodi di strumentazione:
{@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));
}
}}
Ecco una classe latch simile a , java.util.concurrent.CountDownLatch CountDownLatch ad eccezione del fatto che richiede solo un singolo signal elemento da attivare. Poiché un latch non è esclusivo, usa i shared metodi di acquisizione e rilascio.
{@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);
}
}}
Aggiunto nella versione 1.5.
per java.util.concurrent.locks.AbstractQueuedSynchronizer.
Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.
Costruttori
| Nome | Descrizione |
|---|---|
| AbstractQueuedSynchronizer() |
Crea una nuova |
| AbstractQueuedSynchronizer(IntPtr, JniHandleOwnership) |
Costruttore usato durante la creazione di rappresentazioni gestite di oggetti JNI; chiamato dal runtime. |
Proprietà
| Nome | Descrizione |
|---|---|
| Class |
Restituisce la classe di runtime di questo |
| ExclusiveOwnerThread |
Restituisce l'ultimo set di thread da |
| ExclusiveQueuedThreads |
Restituisce un insieme contenente thread in attesa di acquisizione in modalità esclusiva. |
| FirstQueuedThread |
Restituisce il primo thread (in attesa più lungo) nella coda o |
| Handle |
Handle per l'istanza di Android sottostante. (Ereditato da Object) |
| HasContended |
Esegue query sul fatto che qualsiasi thread abbia mai teso ad acquisire questo programma di sincronizzazione; ovvero, se un metodo di acquisizione è mai stato bloccato. |
| HasQueuedPredecessors |
Esegue una query che indica se i thread sono in attesa di acquisire più tempo rispetto al thread corrente. |
| HasQueuedThreads |
Esegue una query che indica se i thread sono in attesa di acquisizione. |
| IsHeldExclusively |
Restituisce |
| JniIdentityHashCode |
Fornisce un framework per implementare blocchi di blocco e sincronizzatori correlati (semafori, eventi e così via) che si basano su code di attesa FIFO (First-In-First Out). (Ereditato da Object) |
| JniPeerMembers |
Fornisce un framework per implementare blocchi di blocco e sincronizzatori correlati (semafori, eventi e così via) che si basano su code di attesa FIFO (First-In-First Out). |
| PeerReference |
Fornisce un framework per implementare blocchi di blocco e sincronizzatori correlati (semafori, eventi e così via) che si basano su code di attesa FIFO (First-In-First Out). (Ereditato da Object) |
| QueuedThreads |
Restituisce un insieme contenente thread in attesa di acquisizione. |
| QueueLength |
Restituisce una stima del numero di thread in attesa di acquisizione. |
| SharedQueuedThreads |
Restituisce una raccolta contenente thread in attesa di acquisizione in modalità condivisa. |
| State |
Restituisce il valore corrente dello stato di sincronizzazione. -oppure- Imposta il valore dello stato di sincronizzazione. |
| ThresholdClass |
Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice. |
| ThresholdType |
Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice. |
Metodi
| Nome | Descrizione |
|---|---|
| Acquire(Int32) |
Acquisisce in modalità esclusiva, ignorando gli interrupt. |
| AcquireInterruptibly(Int32) |
Acquisisce in modalità esclusiva, interrompendo se interrotto. |
| AcquireShared(Int32) |
Acquisisce in modalità condivisa, ignorando gli interrupt. |
| AcquireSharedInterruptibly(Int32) |
Acquisisce in modalità condivisa, interrompendo se interrotto. |
| Clone() |
Crea e restituisce una copia di questo oggetto. (Ereditato da Object) |
| CompareAndSetState(Int32, Int32) |
Imposta in modo atomico lo stato di sincronizzazione sul valore aggiornato specificato se il valore dello stato corrente è uguale al valore previsto. |
| Dispose() |
Fornisce un framework per implementare blocchi di blocco e sincronizzatori correlati (semafori, eventi e così via) che si basano su code di attesa FIFO (First-In-First Out). (Ereditato da Object) |
| Dispose(Boolean) |
Fornisce un framework per implementare blocchi di blocco e sincronizzatori correlati (semafori, eventi e così via) che si basano su code di attesa FIFO (First-In-First Out). (Ereditato da Object) |
| Equals(Object) |
Indica se un altro oggetto è "uguale a" questo. (Ereditato da Object) |
| GetHashCode() |
Restituisce un valore di codice hash per l'oggetto . (Ereditato da Object) |
| GetWaitingThreads(AbstractQueuedSynchronizer+ConditionObject) |
Restituisce un insieme contenente i thread che potrebbero essere in attesa della condizione specificata associata a questo programma di sincronizzazione. |
| GetWaitQueueLength(AbstractQueuedSynchronizer+ConditionObject) |
Restituisce una stima del numero di thread in attesa sulla condizione specificata associata a questo programma di sincronizzazione. |
| HasWaiters(AbstractQueuedSynchronizer+ConditionObject) |
Esegue una query che indica se i thread sono in attesa della condizione specificata associata a questo programma di sincronizzazione. |
| IsQueued(Thread) |
Restituisce true se il thread specificato è attualmente in coda. |
| JavaFinalize() |
Chiamato dal Garbage Collector su un oggetto quando Garbage Collection determina che non sono presenti altri riferimenti all'oggetto . (Ereditato da Object) |
| Notify() |
Riattiva un singolo thread in attesa del monitor dell'oggetto. (Ereditato da Object) |
| NotifyAll() |
Riattiva tutti i thread in attesa del monitor dell'oggetto. (Ereditato da Object) |
| Owns(AbstractQueuedSynchronizer+ConditionObject) |
Esegue una query se l'oggetto ConditionObject specificato usa questo programma di sincronizzazione come blocco. |
| Release(Int32) |
Versioni in modalità esclusiva. |
| ReleaseShared(Int32) |
Versioni in modalità condivisa. |
| SetHandle(IntPtr, JniHandleOwnership) |
Imposta la proprietà Handle. (Ereditato da Object) |
| ToArray<T>() |
Fornisce un framework per implementare blocchi di blocco e sincronizzatori correlati (semafori, eventi e così via) che si basano su code di attesa FIFO (First-In-First Out). (Ereditato da Object) |
| ToString() |
Restituisce una rappresentazione di stringa dell'oggetto . (Ereditato da Object) |
| TryAcquire(Int32) |
Tenta di acquisire in modalità esclusiva. |
| TryAcquireNanos(Int32, Int64) |
Tenta di acquisire in modalità esclusiva, interrompendo se interrotto e non riesce se il timeout specificato è trascorso. |
| TryAcquireShared(Int32) |
Tenta di acquisire in modalità condivisa. |
| TryAcquireSharedNanos(Int32, Int64) |
Tenta di acquisire in modalità condivisa, interrompendo se interrotto e non riesce se il timeout specificato è trascorso. |
| TryRelease(Int32) |
Tenta di impostare lo stato in modo che rifletta una versione in modalità esclusiva. |
| TryReleaseShared(Int32) |
Tenta di impostare lo stato in modo che rifletta una versione in modalità condivisa. |
| UnregisterFromRuntime() |
Fornisce un framework per implementare blocchi di blocco e sincronizzatori correlati (semafori, eventi e così via) che si basano su code di attesa FIFO (First-In-First Out). (Ereditato da Object) |
| Wait() |
Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo <>una notifica</em> o <em>interrotto</em>. (Ereditato da Object) |
| Wait(Int64, Int32) |
Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo<> una notifica</em> o <em>interrotto</em> o fino a quando non è trascorsa una determinata quantità di tempo reale. (Ereditato da Object) |
| Wait(Int64) |
Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo<> una notifica</em> o <em>interrotto</em> o fino a quando non è trascorsa una determinata quantità di tempo reale. (Ereditato da Object) |
Implementazioni dell'interfaccia esplicita
| Nome | Descrizione |
|---|---|
| IJavaPeerable.Disposed() |
Fornisce un framework per implementare blocchi di blocco e sincronizzatori correlati (semafori, eventi e così via) che si basano su code di attesa FIFO (First-In-First Out). (Ereditato da Object) |
| IJavaPeerable.DisposeUnlessReferenced() |
Fornisce un framework per implementare blocchi di blocco e sincronizzatori correlati (semafori, eventi e così via) che si basano su code di attesa FIFO (First-In-First Out). (Ereditato da Object) |
| IJavaPeerable.Finalized() |
Fornisce un framework per implementare blocchi di blocco e sincronizzatori correlati (semafori, eventi e così via) che si basano su code di attesa FIFO (First-In-First Out). (Ereditato da Object) |
| IJavaPeerable.JniManagedPeerState |
Fornisce un framework per implementare blocchi di blocco e sincronizzatori correlati (semafori, eventi e così via) che si basano su code di attesa FIFO (First-In-First Out). (Ereditato da Object) |
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
Fornisce un framework per implementare blocchi di blocco e sincronizzatori correlati (semafori, eventi e così via) che si basano su code di attesa FIFO (First-In-First Out). (Ereditato da Object) |
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
Fornisce un framework per implementare blocchi di blocco e sincronizzatori correlati (semafori, eventi e così via) che si basano su code di attesa FIFO (First-In-First Out). (Ereditato da Object) |
| IJavaPeerable.SetPeerReference(JniObjectReference) |
Fornisce un framework per implementare blocchi di blocco e sincronizzatori correlati (semafori, eventi e così via) che si basano su code di attesa FIFO (First-In-First Out). (Ereditato da Object) |
Metodi di estensione
| Nome | Descrizione |
|---|---|
| GetJniTypeName(IJavaPeerable) |
Ottiene il nome JNI del tipo dell'istanza |
| JavaAs<TResult>(IJavaPeerable) |
Provare a digitare |
| JavaCast<TResult>(IJavaObject) |
Esegue una conversione del tipo di tipo controllato dal runtime Android. |
| JavaCast<TResult>(IJavaObject) |
Fornisce un framework per implementare blocchi di blocco e sincronizzatori correlati (semafori, eventi e così via) che si basano su code di attesa FIFO (First-In-First Out). |
| TryJavaCast<TResult>(IJavaPeerable, TResult) |
Provare a digitare |