StampedLock Classe

Definizione

Spazio dei nomi:

Java.Util.Concurrent.Locks

Assembly:

Mono.Android.dll

Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura.

[Android.Runtime.Register("java/util/concurrent/locks/StampedLock", ApiSince=24, DoNotGenerateAcw=true)]
public class StampedLock : Java.Lang.Object, IDisposable, Java.Interop.IJavaPeerable, Java.IO.ISerializable

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

Ereditarietà

Object

Object

StampedLock

Attributi

RegisterAttribute

Implementazioni

IJavaObject IJavaPeerable ISerializable IDisposable

Commenti

Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura. Lo stato di un stampedLock è costituito da una versione e una modalità. I metodi di acquisizione dei blocchi restituiscono un timbro che rappresenta e controlla l'accesso rispetto a uno stato di blocco; Le versioni "try" di questi metodi possono invece restituire il valore speciale zero per rappresentare un errore di acquisizione dell'accesso. I metodi di rilascio e conversione lock richiedono stamp come argomenti e non riescono se non corrispondono allo stato del blocco. Le tre modalità sono:

<ul>

<li><b>Writing.</b> Metodo #writeLock possibilmente blocca l'attesa dell'accesso esclusivo, restituendo un timbro che può essere usato nel metodo #unlockWrite per rilasciare il blocco. Vengono fornite anche versioni non temporali di tryWriteLock . Quando il blocco viene mantenuto in modalità di scrittura, non è possibile ottenere blocchi di lettura e tutte le convalide di lettura ottimistica avranno esito negativo.

<li><b>Lettura.</b> Metodo #readLock possibilmente blocca l'attesa dell'accesso non esclusivo, restituendo un timbro che può essere usato nel metodo #unlockRead per rilasciare il blocco. Vengono fornite anche versioni non temporali di tryReadLock .

<li><b>Lettura ottimistica.<Il metodo #tryOptimisticRead /b> restituisce un timbro diverso da zero solo se il blocco non è attualmente mantenuto in modalità di scrittura. Il metodo #validate restituisce true se il blocco non è stato acquisito in modalità scrittura dopo aver ottenuto un indicatore specificato, nel qual caso tutte le azioni precedenti alla versione del blocco di scrittura più recente vengono eseguite prima delle azioni che seguono la chiamata a tryOptimisticRead. Questa modalità può essere considerata come una versione estremamente debole di un blocco di lettura, che può essere interrotta da un writer in qualsiasi momento. L'uso della modalità di lettura ottimistica per i segmenti di codice di sola lettura brevi spesso riduce la contesa e migliora la velocità effettiva. Tuttavia, il suo uso è intrinsecamente fragile. Le sezioni di lettura ottimistica devono leggere solo i campi e tenerli nelle variabili locali per usarli in un secondo momento dopo la convalida. I campi letti in modalità di lettura ottimistica potrebbero non essere coerenti, quindi l'utilizzo si applica solo quando si ha familiarità con le rappresentazioni dei dati per controllare la coerenza e/o richiamare ripetutamente il metodo validate(). Ad esempio, questi passaggi sono in genere necessari quando si legge un riferimento a un oggetto o una matrice e quindi si accede a uno dei relativi campi, elementi o metodi.

</ul>

Questa classe supporta anche metodi che forniscono le conversioni in modo condizionale tra le tre modalità. Ad esempio, il metodo #tryConvertToWriteLock tenta di "aggiornare" una modalità, restituendo un timbro di scrittura valido se (1) già in modalità di scrittura (2) in modalità di lettura e non sono disponibili altri lettori o (3) in modalità di lettura ottimistica e il blocco è disponibile. Le forme di questi metodi sono progettate per contribuire a ridurre alcuni dei bloat di codice che altrimenti si verificano nelle progettazioni basate su tentativi.

StampedLocks è progettato per l'uso come utilità interne nello sviluppo di componenti thread-safe. Il loro uso si basa sulla conoscenza delle proprietà interne dei dati, degli oggetti e dei metodi che proteggono. Non sono reentrant, quindi i corpi bloccati non devono chiamare altri metodi sconosciuti che potrebbero tentare di acquisire nuovamente i blocchi (anche se è possibile passare un timbro ad altri metodi che possono usarlo o convertirlo). L'uso delle modalità di blocco di lettura si basa sulle sezioni di codice associate senza effetti collaterali. Le sezioni di lettura ottimistica non convalidate non possono chiamare metodi che non sono noti per tollerare potenziali incoerenze. I francobolli usano rappresentazioni finite e non sono crittograficamente sicuri (ad esempio, un timbro valido può essere indovinabile). I valori stamp possono essere riciclati dopo (non prima di) un anno di funzionamento continuo. Un timbro mantenuto senza utilizzo o convalida per più tempo di questo periodo potrebbe non riuscire a convalidare correttamente. Gli stampedLock sono serializzabili, ma deserializzare sempre in stato di sblocco iniziale, quindi non sono utili per il blocco remoto.

Come java.util.concurrent.Semaphore Semaphore, ma a differenza della maggior Lock parte delle implementazioni, StampedLocks non hanno alcuna nozione di proprietà. I blocchi acquisiti in un thread possono essere rilasciati o convertiti in un altro.

I criteri di pianificazione di StampedLock non preferiscono costantemente i lettori rispetto a writer o viceversa. Tutti i metodi "try" sono il massimo sforzo e non sono necessariamente conformi a criteri di pianificazione o equità. Un valore zero restituito da qualsiasi metodo "try" per l'acquisizione o la conversione dei blocchi non contiene informazioni sullo stato del blocco; una chiamata successiva può avere esito positivo.

Poiché supporta l'utilizzo coordinato tra più modalità di blocco, questa classe non implementa direttamente le Lock interfacce o ReadWriteLock . Tuttavia, un stampedLock può essere visualizzato #asReadLock(), #asWriteLock()o #asReadWriteLock() nelle applicazioni che richiedono solo il set di funzionalità associato.

<b>Sincronizzazione della memoria.<I metodi /b> con l'effetto del corretto blocco in qualsiasi modalità hanno gli stessi effetti di sincronizzazione della memoria di un'azione <em>Lock</em> , come descritto nel capitolo 17 di <cite>The Java Language Specification</cite>. I metodi che sbloccano correttamente in modalità di scrittura hanno gli stessi effetti di sincronizzazione della memoria di un'azione <>di sblocco</em> em. Negli utilizzi di lettura ottimistica, le azioni precedenti all'azione di sblocco della modalità di scrittura più recente vengono garantite prima che si verifichino quelle che seguono un tryOptimisticRead solo se una convalida successiva restituisce true; in caso contrario, non esiste alcuna garanzia che le letture tra tryOptimisticRead e convalidano ottenere uno snapshot coerente.

<b>Esempio di utilizzo.</b> L'esempio seguente illustra alcuni idiomi di utilizzo in una classe che gestisce semplici punti bidimensionali. Il codice di esempio illustra alcune convenzioni try/catch anche se non sono strettamente necessarie perché non possono verificarsi eccezioni nei rispettivi corpi.

{@code
            class Point {
              private double x, y;
              private final StampedLock sl = new StampedLock();

              // an exclusively locked method
              void move(double deltaX, double deltaY) {
                long stamp = sl.writeLock();
                try {
                  x += deltaX;
                  y += deltaY;
                } finally {
                  sl.unlockWrite(stamp);
                }
              }

              // a read-only method
              // upgrade from optimistic read to read lock
              double distanceFromOrigin() {
                long stamp = sl.tryOptimisticRead();
                try {
                  retryHoldingLock: for (;; stamp = sl.readLock()) {
                    if (stamp == 0L)
                      continue retryHoldingLock;
                    // possibly racy reads
                    double currentX = x;
                    double currentY = y;
                    if (!sl.validate(stamp))
                      continue retryHoldingLock;
                    return Math.hypot(currentX, currentY);
                  }
                } finally {
                  if (StampedLock.isReadLockStamp(stamp))
                    sl.unlockRead(stamp);
                }
              }

              // upgrade from optimistic read to write lock
              void moveIfAtOrigin(double newX, double newY) {
                long stamp = sl.tryOptimisticRead();
                try {
                  retryHoldingLock: for (;; stamp = sl.writeLock()) {
                    if (stamp == 0L)
                      continue retryHoldingLock;
                    // possibly racy reads
                    double currentX = x;
                    double currentY = y;
                    if (!sl.validate(stamp))
                      continue retryHoldingLock;
                    if (currentX != 0.0 || currentY != 0.0)
                      break;
                    stamp = sl.tryConvertToWriteLock(stamp);
                    if (stamp == 0L)
                      continue retryHoldingLock;
                    // exclusive access
                    x = newX;
                    y = newY;
                    return;
                  }
                } finally {
                  if (StampedLock.isWriteLockStamp(stamp))
                    sl.unlockWrite(stamp);
                }
              }

              // upgrade read lock to write lock
              void moveIfAtOrigin2(double newX, double newY) {
                long stamp = sl.readLock();
                try {
                  while (x == 0.0 && y == 0.0) {
                    long ws = sl.tryConvertToWriteLock(stamp);
                    if (ws != 0L) {
                      stamp = ws;
                      x = newX;
                      y = newY;
                      break;
                    }
                    else {
                      sl.unlockRead(stamp);
                      stamp = sl.writeLock();
                    }
                  }
                } finally {
                  sl.unlock(stamp);
                }
              }
            }}

Aggiunta nella versione 1.8.

Documentazione java per java.util.concurrent.locks.StampedLock.

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dal progetto Open Source Android e usato in base ai termini descritti nella licenza Creative Commons 2.5 Attribuzione.

Costruttori

StampedLock()	Crea un nuovo blocco, inizialmente in stato sbloccato.
StampedLock(IntPtr, JniHandleOwnership)	Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura.

Proprietà

Class	Restituisce la classe di runtime di questo Objectoggetto . (Ereditato da Object)
Handle	Handle per l'istanza di Android sottostante. (Ereditato da Object)
IsReadLocked	Restituisce true se il blocco è attualmente mantenuto non esclusivamente.
IsWriteLocked	Restituisce true se il blocco è attualmente mantenuto esclusivamente.
JniIdentityHashCode	Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura. (Ereditato da Object)
JniPeerMembers	Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura.
PeerReference	Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura. (Ereditato da Object)
ReadLockCount	Esegue una query sul numero di blocchi di lettura mantenuti per questo blocco.
ThresholdClass	Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura.
ThresholdType	Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura.

Metodi

AsReadLock()	Restituisce una visualizzazione normale Lock di questo stampedLock in cui viene eseguito il mapping del Lock#lock metodo a #readLocke in modo analogo per altri metodi.
AsReadWriteLock()	Restituisce una ReadWriteLock visualizzazione di questo stampedLock in cui viene eseguito il mapping del ReadWriteLock#readLock() metodo a #asReadLock()e ReadWriteLock#writeLock() a #asWriteLock().
AsWriteLock()	Restituisce una visualizzazione normale Lock di questo stampedLock in cui viene eseguito il mapping del Lock#lock metodo a #writeLocke in modo analogo per altri metodi.
Clone()	Crea e restituisce una copia di questo oggetto. (Ereditato da Object)
Dispose()	Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura. (Ereditato da Object)
Dispose(Boolean)	Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura. (Ereditato da Object)
Equals(Object)	Indica se un altro oggetto è "uguale a" questo. (Ereditato da Object)
GetHashCode()	Restituisce un valore del codice hash per l'oggetto. (Ereditato da Object)
IsLockStamp(Int64)	Indica se un timbro rappresenta il blocco.
IsOptimisticReadStamp(Int64)	Indica se un timbro rappresenta una lettura ottimistica riuscita.
IsReadLockStamp(Int64)	Indica se un timbro rappresenta un blocco non esclusivo.
IsWriteLockStamp(Int64)	Indica se un timbro rappresenta esclusivamente un blocco.
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()	Non esclusivamente acquisisce il blocco, bloccando se necessario fino a quando non è disponibile.
ReadLockInterruptibly()	Acquisisce in modo non esclusivo il blocco, bloccando se necessario fino a quando non è disponibile o il thread corrente viene interrotto.
SetHandle(IntPtr, JniHandleOwnership)	Imposta la proprietà Handle. (Ereditato da Object)
ToArray<T>()	Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura. (Ereditato da Object)
ToString()	Restituisce una rappresentazione di stringa dell'oggetto. (Ereditato da Object)
TryConvertToOptimisticRead(Int64)	Se lo stato del blocco corrisponde allo stamp specificato, in modo atomico, se il timbro rappresenta il blocco, lo rilascia e restituisce un timbro di osservazione.
TryConvertToReadLock(Int64)	Se lo stato del blocco corrisponde al timbro specificato, esegue in modo atomico una delle azioni seguenti.
TryConvertToWriteLock(Int64)	Se lo stato del blocco corrisponde al timbro specificato, esegue in modo atomico una delle azioni seguenti.
TryOptimisticRead()	Restituisce un timbro che può essere convalidato in un secondo momento oppure zero se bloccato esclusivamente.
TryReadLock()	Non esclusivamente acquisisce il blocco se è immediatamente disponibile.
TryReadLock(Int64, TimeUnit)	Non esclusivamente acquisisce il blocco se è disponibile entro il tempo specificato e il thread corrente non è stato interrotto.
TryUnlockRead()	Rilascia un blocco di lettura se è mantenuto, senza richiedere un valore stamp.
TryUnlockWrite()	Rilascia il blocco di scrittura se è mantenuto, senza richiedere un valore stamp.
TryWriteLock()	Acquisisce esclusivamente il blocco se è immediatamente disponibile.
TryWriteLock(Int64, TimeUnit)	Acquisisce esclusivamente il blocco se è disponibile entro il tempo specificato e il thread corrente non è stato interrotto.
Unlock(Int64)	Se lo stato del blocco corrisponde al timbro specificato, rilascia la modalità corrispondente del blocco.
UnlockRead(Int64)	Se lo stato del blocco corrisponde al timbro specificato, rilascia il blocco non esclusivo.
UnlockWrite(Int64)	Se lo stato del blocco corrisponde al timbro specificato, rilascia il blocco esclusivo.
UnregisterFromRuntime()	Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura. (Ereditato da Object)
Validate(Int64)	Restituisce true se il blocco non è stato acquisito esclusivamente dopo il rilascio del timbro specificato.
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()	Acquisisce esclusivamente il blocco, bloccando se necessario fino a quando disponibile.
WriteLockInterruptibly()	Acquisisce esclusivamente il blocco, bloccando se necessario fino a quando non è disponibile o il thread corrente viene interrotto.

Implementazioni dell'interfaccia esplicita

IJavaPeerable.Disposed()	Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura. (Ereditato da Object)
IJavaPeerable.DisposeUnlessReferenced()	Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura. (Ereditato da Object)
IJavaPeerable.Finalized()	Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura. (Ereditato da Object)
IJavaPeerable.JniManagedPeerState	Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura. (Ereditato da Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura. (Ereditato da Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura. (Ereditato da Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura. (Ereditato da Object)

Metodi di estensione

JavaCast<TResult>(IJavaObject)	Esegue una conversione del tipo di tipo controllato dal runtime Android.
JavaCast<TResult>(IJavaObject)	Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura.
GetJniTypeName(IJavaPeerable)	Un blocco basato su funzionalità con tre modalità per controllare l'accesso in lettura/scrittura.