LockSupport Classe

Definizione

[Android.Runtime.Register("java/util/concurrent/locks/LockSupport", DoNotGenerateAcw=true)]
public class LockSupport : Java.Lang.Object

[<Android.Runtime.Register("java/util/concurrent/locks/LockSupport", DoNotGenerateAcw=true)>]
type LockSupport = class
    inherit Object

Ereditarietà

Object

JavaObject

Object

LockSupport

Attributi

RegisterAttribute

Commenti

Primitive di blocco dei thread di base per la creazione di blocchi e altre classi di sincronizzazione.

Questa classe associa, a ogni thread che lo usa, un permesso (nel senso della java.util.concurrent.Semaphore Semaphore classe). Una chiamata a park restituirà immediatamente se il permesso è disponibile, lo utilizza nel processo; in caso contrario <, em>può</em> blocco. Una chiamata a unpark rende disponibile il permesso, se non era già disponibile. A differenza dei semafori, però, i permessi non si accumulano. C'è al massimo uno.) L'utilizzo affidabile richiede l'uso di variabili volatili (o atomiche) per controllare quando parcheggiare o rimuovere il parco. Gli ordini delle chiamate a questi metodi vengono mantenuti in relazione agli accessi a variabili volatili, ma non necessariamente agli accessi a variabili non volatili.

I metodi park e unpark forniscono mezzi efficienti per bloccare e sbloccare i thread che non riscontrano i problemi che causano i metodi Thread.suspend deprecati e Thread.resume non possono essere usati per tali scopi: gare tra un thread che richiama park e un altro thread che tenta unpark di conservare la durata, a causa del permesso. Inoltre, park restituirà se il thread del chiamante è stato interrotto e le versioni di timeout sono supportate. Il park metodo può anche restituire in qualsiasi altro momento, per "nessun motivo", quindi in generale deve essere richiamato all'interno di un ciclo che controlla nuovamente le condizioni al momento della restituzione. In questo senso park funge da ottimizzazione di una "attesa occupata" che non sprecare tanto tempo rotazione, ma deve essere abbinato a un unpark per essere efficace.

Le tre forme di park ognuna supportano anche un blocker parametro oggetto. Questo oggetto viene registrato mentre il thread è bloccato per consentire il monitoraggio e gli strumenti di diagnostica per identificare i motivi per cui i thread sono bloccati. Tali strumenti possono accedere ai bloccanti usando il metodo #getBlocker(Thread). L'uso di queste forme anziché le forme originali senza questo parametro è fortemente incoraggiato. L'argomento normale da fornire come all'interno di un'implementazione di blocker blocco è this.

Questi metodi sono progettati per essere usati come strumenti per la creazione di utilità di sincronizzazione di livello superiore e non sono in sé utili per la maggior parte delle applicazioni di controllo della concorrenza. Il park metodo è progettato per l'uso solo nelle costruzioni del formato:

{@code
            while (!canProceed()) {
              // ensure request to unpark is visible to other threads
              ...
              LockSupport.park(this);
            }}

dove nessuna azione da parte del thread che pubblica una richiesta di unpark, prima della chiamata a park, comporta il blocco o il blocco. Poiché a ogni thread è associato un solo permesso, qualsiasi uso intermedio di park, incluso in modo implicito tramite il caricamento delle classi, potrebbe causare un thread non rispondente (un "unpark perso").

<b>Esempio di utilizzo.</b> Ecco uno schizzo di una classe di blocco non reentrant first-in-first-out:

{@code
            class FIFOMutex {
              private final AtomicBoolean locked = new AtomicBoolean(false);
              private final Queue<Thread> waiters
                = new ConcurrentLinkedQueue<>();

              public void lock() {
                boolean wasInterrupted = false;
                // publish current thread for unparkers
                waiters.add(Thread.currentThread());

                // Block while not first in queue or cannot acquire lock
                while (waiters.peek() != Thread.currentThread() ||
                       !locked.compareAndSet(false, true)) {
                  LockSupport.park(this);
                  // ignore interrupts while waiting
                  if (Thread.interrupted())
                    wasInterrupted = true;
                }

                waiters.remove();
                // ensure correct interrupt status on return
                if (wasInterrupted)
                  Thread.currentThread().interrupt();
              }

              public void unlock() {
                locked.set(false);
                LockSupport.unpark(waiters.peek());
              }

              static {
                // Reduce the risk of "lost unpark" due to classloading
                Class<?> ensureLoaded = LockSupport.class;
              }
            }}

Aggiunto nella versione 1.5.

per java.util.concurrent.locks.LockSupport.

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.