ReentrantReadWriteLock 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.
Implementazione del supporto di ReadWriteLock semantica simile a ReentrantLock.
[Android.Runtime.Register("java/util/concurrent/locks/ReentrantReadWriteLock", DoNotGenerateAcw=true)]
public class ReentrantReadWriteLock : Java.Lang.Object, IDisposable, Java.Interop.IJavaPeerable, Java.IO.ISerializable, Java.Util.Concurrent.Locks.IReadWriteLock[<Android.Runtime.Register("java/util/concurrent/locks/ReentrantReadWriteLock", DoNotGenerateAcw=true)>]
type ReentrantReadWriteLock = class
inherit Object
interface ISerializable
interface IJavaObject
interface IDisposable
interface IJavaPeerable
interface IReadWriteLock- Ereditarietà
- Attributi
- Implementazioni
Commenti
Implementazione del supporto di ReadWriteLock semantica simile a ReentrantLock.
Questa classe ha le proprietà seguenti:
<ul><li><b>Ordine acquisizione</b>
Questa classe non impone un ordine di preferenza lettore o writer per l'accesso di blocco. Tuttavia, supporta un criterio facoltativo <>em equità</em>.
<dl><dt><b>Modalità non equa (impostazione predefinita)</b><dd>Se costruito come non equo (impostazione predefinita), l'ordine di immissione per il blocco di lettura e scrittura non è specificato, soggetto a vincoli di reentrancy. Un blocco non faire che viene continuamente teso può rimandare a un tempo indefinito uno o più thread lettore o writer, ma in genere avrà una velocità effettiva superiore rispetto a un blocco equo.
<dt><b>Fair mode</b><dd>Quando costruito come equo, i thread lottano per l'ingresso usando un criterio di arrivo approssimativo. Quando il blocco attualmente mantenuto viene rilasciato, al thread del writer in attesa più lungo verrà assegnato il blocco di scrittura oppure se è presente un gruppo di thread lettore in attesa di più tempo rispetto a tutti i thread del writer in attesa, a tale gruppo verrà assegnato il blocco di lettura.
Un thread che tenta di acquisire un blocco di lettura equo (non reentrantly) blocca se il blocco di scrittura viene mantenuto o è presente un thread del writer in attesa. Il thread non acquisirà il blocco di lettura fino a quando il thread writer in attesa meno recente ha acquisito e rilasciato il blocco di scrittura. Naturalmente, se un writer in attesa abbandona l'attesa, lasciando uno o più thread lettore come camerieri più lunghi nella coda con il blocco di scrittura gratuito, a tali lettori verrà assegnato il blocco di lettura.
Un thread che tenta di acquisire un blocco di scrittura equo (non reentrantly) verrà bloccato a meno che sia il blocco di lettura che il blocco di scrittura siano liberi (il che implica che non ci sono thread in attesa). Si noti che i metodi e ReadLock#tryLock() non bloccanti WriteLock#tryLock() non rispettano questa impostazione equa e acquisiranno immediatamente il blocco, se possibile, indipendentemente dai thread in attesa. </dl>
<li><b>Reentrancy</b>
Questo blocco consente sia ai lettori che ai writer di riacquisire blocchi di lettura o scrittura nello stile di un oggetto ReentrantLock. I lettori non rientranti non sono consentiti fino a quando non vengono rilasciati tutti i blocchi di scrittura mantenuti dal thread di scrittura.
Inoltre, un writer può acquisire il blocco di lettura, ma non viceversa. Tra le altre applicazioni, la reentrancy può essere utile quando i blocchi di scrittura vengono mantenuti durante le chiamate o i callback ai metodi che eseguono letture in blocchi di lettura. Se un lettore tenta di acquisire il blocco di scrittura, non avrà mai esito positivo.
<li><b>Lock downgrading</b>
La reentrancy consente anche il downgrade dal blocco di scrittura a un blocco di lettura, acquisendo il blocco di scrittura, quindi il blocco di lettura e quindi rilasciando il blocco di scrittura. Tuttavia, l'aggiornamento da un blocco di lettura al blocco di scrittura è <b>non</b> possibile.
<li><b>Interruzione del blocco acquisizione</b>
Il blocco di lettura e il blocco di scrittura supportano entrambe l'interruzione durante l'acquisizione del blocco.
<supporto>< li>bCondition</b>
Il blocco di scrittura fornisce un'implementazione Condition che si comporta nello stesso modo, rispetto al blocco di scrittura, come l'implementazione Condition fornita da ReentrantLock#newCondition per ReentrantLock. Questo Condition può, naturalmente, essere usato solo con il blocco di scrittura.
Il blocco di lettura non supporta e ConditionreadLock().newCondition() genera UnsupportedOperationException.
<li><b>Instrumentation</b>
Questa classe supporta i metodi per determinare se i blocchi vengono mantenuti o in genere. Questi metodi sono progettati per il monitoraggio dello stato del sistema, non per il controllo della sincronizzazione. </ul>
La serializzazione di questa classe si comporta nello stesso modo dei blocchi predefiniti: un blocco deserializzato si trova nello stato sbloccato, indipendentemente dal relativo stato durante la serializzazione.
<b>Esempi di utilizzo.</b> Ecco uno schizzo di codice che illustra come eseguire il downgrade del blocco dopo l'aggiornamento di una cache (la gestione delle eccezioni è particolarmente complessa quando si gestiscono più blocchi in modo non annidato):
{@code
class CachedData {
Object data;
boolean cacheValid;
final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
void processCachedData() {
rwl.readLock().lock();
if (!cacheValid) {
// Must release read lock before acquiring write lock
rwl.readLock().unlock();
rwl.writeLock().lock();
try {
// Recheck state because another thread might have
// acquired write lock and changed state before we did.
if (!cacheValid) {
data = ...;
cacheValid = true;
}
// Downgrade by acquiring read lock before releasing write lock
rwl.readLock().lock();
} finally {
rwl.writeLock().unlock(); // Unlock write, still hold read
}
}
try {
use(data);
} finally {
rwl.readLock().unlock();
}
}
}}
ReentrantReadWriteLocks può essere usato per migliorare la concorrenza in alcuni usi di alcuni tipi di raccolte. Ciò è in genere utile solo quando si prevede che le raccolte siano di grandi dimensioni, a cui si accede da più thread lettore rispetto ai thread del writer e comportano operazioni con overhead che superano il sovraccarico della sincronizzazione. Ad esempio, ecco una classe che usa una Mappa ad albero che dovrebbe essere grande e accessibile contemporaneamente.
{@code
class RWDictionary {
private final Map<String, Data> m = new TreeMap<>();
private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
private final Lock r = rwl.readLock();
private final Lock w = rwl.writeLock();
public Data get(String key) {
r.lock();
try { return m.get(key); }
finally { r.unlock(); }
}
public List<String> allKeys() {
r.lock();
try { return new ArrayList<>(m.keySet()); }
finally { r.unlock(); }
}
public Data put(String key, Data value) {
w.lock();
try { return m.put(key, value); }
finally { w.unlock(); }
}
public void clear() {
w.lock();
try { m.clear(); }
finally { w.unlock(); }
}
}}
<Note> sull'implementazione h2</h2>
Questo blocco supporta un massimo di 65535 blocchi di scrittura ricorsivi e 65535 blocchi di lettura. I tentativi di superare questi limiti generano Error un'eccezione dai metodi di blocco.
Aggiunto nella versione 1.5.
per java.util.concurrent.locks.ReentrantReadWriteLock.
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 |
|---|---|
| ReentrantReadWriteLock() |
Crea un nuovo |
| ReentrantReadWriteLock(Boolean) |
Crea un nuovo |
| ReentrantReadWriteLock(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 |
| Handle |
Handle per l'istanza di Android sottostante. (Ereditato da Object) |
| HasQueuedThreads |
Esegue una query che indica se i thread sono in attesa di acquisire il blocco di lettura o scrittura. |
| IsFair |
Restituisce |
| IsWriteLocked |
Esegue query se il blocco di scrittura viene mantenuto da qualsiasi thread. |
| IsWriteLockedByCurrentThread |
Esegue query se il blocco di scrittura viene mantenuto dal thread corrente. |
| JniIdentityHashCode |
Ottiene il codice hash di identità assegnato a questo Java peer dal runtime di interoperabilità. (Ereditato da Object) |
| JniPeerMembers |
Implementazione del supporto di |
| Owner |
Restituisce il thread proprietario del blocco di scrittura o |
| PeerReference |
Ottiene il riferimento all'oggetto JNI per questo peer Java. (Ereditato da Object) |
| QueuedReaderThreads |
Restituisce un insieme contenente thread in attesa di acquisire il blocco di lettura. |
| QueuedThreads |
Restituisce un insieme contenente thread in attesa di acquisire il blocco di lettura o scrittura. |
| QueuedWriterThreads |
Restituisce un insieme contenente thread in attesa di acquisire il blocco di scrittura. |
| QueueLength |
Restituisce una stima del numero di thread in attesa di acquisire il blocco di lettura o scrittura. |
| ReadHoldCount |
Esegue una query sul numero di blocchi di lettura reentrant su questo blocco dal thread corrente. |
| ReadLockCount |
Esegue una query sul numero di blocchi di lettura mantenuti per questo blocco. |
| 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. |
| WriteHoldCount |
Esegue una query sul numero di blocchi di scrittura reentrant in questo blocco dal thread corrente. |
Metodi
| Nome | Descrizione |
|---|---|
| Clone() |
Crea e restituisce una copia di questo oggetto. (Ereditato da Object) |
| Dispose() |
Rilascia le risorse contenute in questo peer Java. (Ereditato da Object) |
| Dispose(Boolean) |
Rilascia le risorse contenute in questo peer Java. (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(ICondition) |
Restituisce un insieme contenente i thread che potrebbero essere in attesa della condizione specificata associata al blocco di scrittura. |
| GetWaitQueueLength(ICondition) |
Restituisce una stima del numero di thread in attesa della condizione specificata associata al blocco di scrittura. |
| HasQueuedThread(Thread) |
Esegue una query se il thread specificato è in attesa di acquisire il blocco di lettura o scrittura. |
| HasWaiters(ICondition) |
Esegue una query che indica se i thread sono in attesa della condizione specificata associata al blocco di scrittura. |
| 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) |
| ReadLock() |
Restituisce il blocco utilizzato per la lettura. |
| SetHandle(IntPtr, JniHandleOwnership) |
Imposta la proprietà Handle. (Ereditato da Object) |
| ToArray<T>() |
Crea una matrice gestita da questo wrapper di matrice Java. (Ereditato da Object) |
| ToString() |
Restituisce una rappresentazione di stringa dell'oggetto . (Ereditato da Object) |
| UnregisterFromRuntime() |
Annulla la registrazione di questo Java peer dal runtime di interoperabilità. (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) |
| WriteLock() |
Restituisce il blocco utilizzato per la scrittura. |
Implementazioni dell'interfaccia esplicita
| Nome | Descrizione |
|---|---|
| IJavaPeerable.Disposed() |
Notifica al runtime di interoperabilità che il peer gestito è stato eliminato. (Ereditato da Object) |
| IJavaPeerable.DisposeUnlessReferenced() |
Rilascia questo Java peer a meno che non venga conservato da un altro riferimento gestito. (Ereditato da Object) |
| IJavaPeerable.Finalized() |
Notifica al runtime di interoperabilità che il peer gestito è stato finalizzato. (Ereditato da Object) |
| IJavaPeerable.JniManagedPeerState |
Ottiene lo stato che descrive la relazione tra questo peer gestito e il relativo riferimento JNI. (Ereditato da Object) |
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
Imposta il codice hash dell'identità di interoperabilità per questo Java peer. (Ereditato da Object) |
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
Imposta lo stato peer gestito e JNI per questo peer Java. (Ereditato da Object) |
| IJavaPeerable.SetPeerReference(JniObjectReference) |
Imposta il riferimento all'oggetto JNI usato da questo peer gestito. (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) |
Implementazione del supporto di |
| TryJavaCast<TResult>(IJavaPeerable, TResult) |
Provare a digitare |