Semaphore Classe

Riferimento

Definizione

Spazio dei nomi:: Java.Util.Concurrent

Assembly:: Mono.Android.dll

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.

Un semaforo di conteggio.

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

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

Ereditarietà: Object

Object
Semaphore

Attributi: RegisterAttribute

Implementazioni: IJavaObject IJavaPeerable ISerializable IDisposable

Commenti

Un semaforo di conteggio. Concettualmente, un semaforo mantiene un set di autorizzazioni. Ogni #acquire blocco, se necessario, fino a quando non è disponibile un permesso e quindi lo accetta. Ogni #release oggetto aggiunge un'autorizzazione, potenzialmente rilasciando un acquisizione di blocco. Tuttavia, non vengono usati oggetti consentiti effettivi; il Semaphore solo mantiene un conteggio del numero disponibile e agisce di conseguenza.

I semafori vengono spesso usati per limitare il numero di thread che possono accedere a una risorsa (fisica o logica). Ad esempio, ecco una classe che usa un semaforo per controllare l'accesso a un pool di elementi:

{@code
            class Pool {
              private static final int MAX_AVAILABLE = 100;
              private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);

              public Object getItem() throws InterruptedException {
                available.acquire();
                return getNextAvailableItem();
              }

              public void putItem(Object x) {
                if (markAsUnused(x))
                  available.release();
              }

              // Not a particularly efficient data structure; just for demo

              protected Object[] items = ...; // whatever kinds of items being managed
              protected boolean[] used = new boolean[MAX_AVAILABLE];

              protected synchronized Object getNextAvailableItem() {
                for (int i = 0; i < MAX_AVAILABLE; ++i) {
                  if (!used[i]) {
                    used[i] = true;
                    return items[i];
                  }
                }
                return null; // not reached
              }

              protected synchronized boolean markAsUnused(Object item) {
                for (int i = 0; i < MAX_AVAILABLE; ++i) {
                  if (item == items[i]) {
                    if (used[i]) {
                      used[i] = false;
                      return true;
                    } else
                      return false;
                  }
                }
                return false;
              }
            }}

Prima di ottenere un elemento ogni thread deve acquisire un'autorizzazione dal semaforo, garantendo che un elemento sia disponibile per l'uso. Al termine del thread con l'elemento restituito al pool e viene restituito un autorizzazione al semaforo, consentendo a un altro thread di acquisire tale elemento. Si noti che non viene mantenuto alcun blocco di sincronizzazione quando #acquire viene chiamato in quanto impedisce che un elemento venga restituito al pool. Il semaforo incapsula la sincronizzazione necessaria per limitare l'accesso al pool, separatamente da qualsiasi sincronizzazione necessaria per mantenere la coerenza del pool stesso.

Un semaforo inizializzato in uno e che viene usato in modo che abbia solo un'autorizzazione disponibile, può fungere da blocco di esclusione reciproca. Questo è più comunemente noto come <semaforo binario em>, perché ha solo due stati: uno permesso disponibile o zero consente di essere disponibili. Se usato in questo modo, il semaforo binario ha la proprietà (a differenza di molte java.util.concurrent.locks.Lock implementazioni), che la " blocco&virgolette; può essere rilasciato da un thread diverso dal proprietario (come i semafori non hanno alcuna nozione di proprietà). Questo può essere utile in alcuni contesti specializzati, ad esempio il ripristino di deadlock.

Il costruttore per questa classe accetta facoltativamente un <parametro em>fairness . Se impostato su false, questa classe non garantisce l'ordine in cui i thread acquisiscono le autorizzazioni. In particolare, barging è consentito, ovvero un thread che #acquire richiama può essere allocato un consentito prima di un thread in attesa- logicamente il nuovo thread si posiziona alla testa della coda di thread in attesa. Quando l'equità è impostata su true, il semaforo garantisce che i thread che richiamano uno dei #acquire() acquire metodi siano selezionati per ottenere le autorizzazioni nell'ordine in cui è stata elaborata la chiamata di tali metodi (first-in-first-out; FIFO). Si noti che l'ordinamento FIFO si applica necessariamente a punti interni specifici di esecuzione all'interno di questi metodi. È quindi possibile richiamare acquire un thread prima di un altro, ma raggiungere il punto di ordinamento dopo l'altro e analogamente al ritorno dal metodo. Si noti anche che i metodi non tempod #tryAcquire() tryAcquire non rispettano l'impostazione di equità, ma prenderanno qualsiasi autorizzazione disponibile.

In genere, i semafori usati per controllare l'accesso alle risorse devono essere inizializzati in modo equo, per assicurarsi che nessun thread sia bloccato dall'accesso a una risorsa. Quando si usano i semafori per altri tipi di controllo di sincronizzazione, i vantaggi della velocità effettiva dell'ordine non equo spesso superano le considerazioni di equità.

Questa classe offre anche metodi pratici per #acquire(int) acquire e #release(int) release più autorizzazioni alla volta. Questi metodi sono in genere più efficienti ed efficaci rispetto ai cicli. Tuttavia, non stabiliscono alcun ordine di preferenza. Ad esempio, se thread A richiama s.acquire(3) e thread B richiama s.acquire(2), e due autorizzazioni diventano disponibili, non esiste alcuna garanzia che il thread B li otterrà a meno che l'acquisizione non sia stata prima e Semaphore s sia in modalità fair.

Effetti di coerenza della memoria: azioni in un thread prima di chiamare un metodo "release", ad esempio i happen-before> actions seguendo un metodo "acquisizione" riuscito, ad acquire() esempio release()<in un altro thread.

Aggiunto nella versione 1.5.

Documentazione Java per java.util.concurrent.Semaphore.

Le parti di questa pagina sono modifiche in base al lavoro creato e condiviso dal Android Open Source e usato in base ai termini descritti nella .

Costruttori

Semaphore(Int32)	Crea un oggetto `Semaphore` con il numero specificato di autorizzazioni e l'impostazione di equità non fair.
Semaphore(Int32, Boolean)	Crea un oggetto `Semaphore` con il numero specificato di autorizzazioni e l'impostazione di equità specificata.
Semaphore(IntPtr, JniHandleOwnership)	Costruttore usato durante la creazione di rappresentazioni gestite di oggetti JNI; chiamato dal runtime.

Proprietà

Class	Restituisce la classe di runtime di questo `Object`oggetto . (Ereditato da Object)
Handle	Handle all'istanza di Android sottostante. (Ereditato da Object)
HasQueuedThreads	Esegue query sul fatto che tutti i thread siano in attesa di acquisire.
IsFair	Restituisce `true` se questo semaforo ha l'equità impostata su true.
JniIdentityHashCode	Un semaforo di conteggio. (Ereditato da Object)
JniPeerMembers	Un semaforo di conteggio.
PeerReference	Un semaforo di conteggio. (Ereditato da Object)
QueuedThreads	Restituisce una raccolta contenente thread che potrebbero attendere l'acquisizione.
QueueLength	Restituisce una stima del numero di thread in attesa di acquisizione.
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

Acquire()	Acquisisce un'autorizzazione da questo semaforo, bloccando fino a quando non è disponibile o il thread è Thread#interrupt interrotto.
Acquire(Int32)	Acquisisce il numero specificato di autorizzazioni da questo semaforo, bloccando fino a quando non sono disponibili tutti o il thread è Thread#interrupt interrotto.
AcquireUninterruptibly()	Acquisisce un'autorizzazione da questo semaforo, bloccando fino a quando non è disponibile.
AcquireUninterruptibly(Int32)	Acquisisce il numero specificato di autorizzazioni da questo semaforo, bloccando fino a quando tutti sono disponibili.
AvailablePermits()	Restituisce il numero corrente di autorizzazioni disponibili in questo semaforo.
Clone()	Crea e restituisce una copia di questo oggetto. (Ereditato da Object)
Dispose()	Un semaforo di conteggio. (Ereditato da Object)
Dispose(Boolean)	Un semaforo di conteggio. (Ereditato da Object)
DrainPermits()	Acquisisce e restituisce tutti i permessi immediatamente disponibili o, se sono disponibili autorizzazioni negative, le rilascia.
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)
JavaFinalize()	Chiamato dal Garbage Collector in un oggetto quando Garbage Collection determina che non sono presenti più riferimenti all'oggetto. (Ereditato da Object)
Notify()	Riattiva un singolo thread in attesa del monitoraggio dell'oggetto. (Ereditato da Object)
NotifyAll()	Riattiva tutti i thread in attesa del monitoraggio dell'oggetto. (Ereditato da Object)
ReducePermits(Int32)	Riduce il numero di autorizzazioni disponibili dalla riduzione indicata.
Release()	Rilascia un permesso, restituendolo al semaforo.
Release(Int32)	Rilascia il numero specificato di permessi, restituendoli al semaforo.
SetHandle(IntPtr, JniHandleOwnership)	Imposta la proprietà Handle. (Ereditato da Object)
ToArray<T>()	Un semaforo di conteggio. (Ereditato da Object)
ToString()	Restituisce una rappresentazione in formato stringa dell'oggetto. (Ereditato da Object)
TryAcquire()	Acquisisce un permesso da questo semaforo, solo se uno è disponibile al momento della chiamata.
TryAcquire(Int32)	Acquisisce il numero specificato di permessi da questo semaforo, solo se tutti sono disponibili al momento della chiamata.
TryAcquire(Int32, Int64, TimeUnit)	Acquisisce il numero specificato di autorizzazioni da questo semaforo, se tutti diventano disponibili entro il tempo di attesa specificato e il thread corrente non è stato interrotto thread#interrupt.
TryAcquire(Int64, TimeUnit)	Acquisisce un'autorizzazione da questo semaforo, se uno diventa disponibile entro il tempo di attesa specificato e il thread corrente non è stato interrotto Thread#interrupt.
UnregisterFromRuntime()	Un semaforo di conteggio. (Ereditato da Object)
Wait()	Causa l'attesa del thread corrente fino a quando non viene svegliata, in genere eseguendo>una notifica</em o <em interrotto</>em>>.< (Ereditato da Object)
Wait(Int64)	Causa l'attesa del thread corrente fino a quando non viene svegliata, in genere <>eseguendo una notifica</em o <em interrotto/>>em>o fino a quando non è trascorsa< una determinata quantità di tempo reale. (Ereditato da Object)
Wait(Int64, Int32)	Causa l'attesa del thread corrente fino a quando non viene svegliata, in genere <>eseguendo 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

IJavaPeerable.Disposed()	Un semaforo di conteggio. (Ereditato da Object)
IJavaPeerable.DisposeUnlessReferenced()	Un semaforo di conteggio. (Ereditato da Object)
IJavaPeerable.Finalized()	Un semaforo di conteggio. (Ereditato da Object)
IJavaPeerable.JniManagedPeerState	Un semaforo di conteggio. (Ereditato da Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Un semaforo di conteggio. (Ereditato da Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Un semaforo di conteggio. (Ereditato da Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Un semaforo di conteggio. (Ereditato da Object)

Metodi di estensione

JavaCast<TResult>(IJavaObject)	Esegue una conversione dei tipi controllati dal runtime Android.
JavaCast<TResult>(IJavaObject)	Un semaforo di conteggio.
GetJniTypeName(IJavaPeerable)	Un semaforo di conteggio.

Si applica a

Share via