Semaphore 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.
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à
- Attributi
- Implementazioni
Commenti
Semaforo di conteggio. Concettualmente, un semaforo mantiene un set di permessi. Ogni #acquire blocco, se necessario, fino a quando non è disponibile un permesso e quindi lo accetta. Ogni #release aggiunge un permesso, potenzialmente rilasciando un acquisitore di blocco. Tuttavia, non vengono utilizzati 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). Ecco ad esempio 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 permesso 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 permesso 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 come in questo modo si 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, che viene usato in modo che abbia al massimo un permesso 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 permesso disponibile. Se usato in questo modo, il semaforo binario ha la proprietà (a differenza di molte java.util.concurrent.locks.Lock implementazioni), che il " blocco " può essere rilasciato da un thread diverso dal proprietario (come semafori non hanno alcuna nozione di proprietà). Ciò può essere utile in alcuni contesti specializzati, ad esempio il ripristino del deadlock.
Il costruttore per questa classe accetta facoltativamente un <parametro em>fairness</em> . Se impostata su false, questa classe non garantisce l'ordine in cui i thread acquisiscono i permessi. In particolare, <em>barging</em> è consentito, ovvero un thread che richiama #acquire può essere allocato un permesso prima di un thread in attesa, logicamente il nuovo thread si posiziona all'inizio 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 i permessi nell'ordine in cui è stata elaborata la loro chiamata di tali metodi (first-in-first-out; FIFO). Si noti che l'ordinamento FIFO si applica necessariamente a specifici punti interni di esecuzione all'interno di questi metodi. Pertanto, è possibile che un thread richiami acquire prima di un altro, ma raggiunga il punto di ordinamento dopo l'altro e analogamente al ritorno dal metodo . Si noti anche che i metodi non previsti #tryAcquire() tryAcquire non rispettano l'impostazione di equità, ma accettano eventuali permessi disponibili.
In genere, i semafori usati per controllare l'accesso alle risorse devono essere inizializzati come equi, per garantire che nessun thread non sia bloccato dall'accesso a una risorsa. Quando si usano semafori per altri tipi di controllo della sincronizzazione, i vantaggi della velocità effettiva dell'ordinamento non equo spesso superano le considerazioni di equità.
Questa classe fornisce anche metodi pratici a #acquire(int) acquire e #release(int) release più autorizzazioni per volta. Questi metodi sono in genere più efficienti ed efficaci rispetto ai cicli. Tuttavia, non stabiliscono alcun ordine di preferenza. Ad esempio, se il thread A richiama ) e il thread B richiama s.acquire(3s.acquire(2)e due permessi diventano disponibili, non c'è alcuna garanzia che il thread B li otterrà a meno che l'acquisizione non sia arrivata per prima e Semaphore s sia in modalità equa.
Effetti di coerenza della memoria: azioni in un thread prima di chiamare un metodo "release", ad esempio release()<le>azioni prima</i> che seguono un metodo di "acquisizione" riuscito, acquire() ad esempio in un altro thread.
Aggiunto nella versione 1.5.
per java.util.concurrent.Semaphore.
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 |
|---|---|
| Semaphore(Int32, Boolean) |
Crea un |
| Semaphore(Int32) |
Crea un |
| Semaphore(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 acquisizione. |
| IsFair |
Restituisce |
| JniIdentityHashCode |
Semaforo di conteggio. (Ereditato da Object) |
| JniPeerMembers |
Semaforo di conteggio. |
| PeerReference |
Semaforo di conteggio. (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. |
| 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() |
Acquisisce un permesso da questo semaforo, bloccando fino a quando non ne è disponibile uno o il thread è Thread#interrupt interrotto. |
| Acquire(Int32) |
Acquisisce il numero specificato di permessi da questo semaforo, bloccando fino a quando non sono disponibili tutti o il thread è Thread#interrupt interrotto. |
| AcquireUninterruptibly() |
Acquisisce un permesso da questo semaforo, bloccando fino a quando non ne è disponibile uno. |
| AcquireUninterruptibly(Int32) |
Acquisisce il numero specificato di permessi da questo semaforo, bloccando fino a quando non sono disponibili tutti. |
| AvailablePermits() |
Restituisce il numero corrente di permessi disponibili in questo semaforo. |
| Clone() |
Crea e restituisce una copia di questo oggetto. (Ereditato da Object) |
| Dispose() |
Semaforo di conteggio. (Ereditato da Object) |
| Dispose(Boolean) |
Semaforo di conteggio. (Ereditato da Object) |
| DrainPermits() |
Acquisisce e restituisce tutti i permessi immediatamente disponibili o, se sono disponibili permessi negativi, li 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 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) |
| ReducePermits(Int32) |
Riduce il numero di permessi disponibili in base alla 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>() |
Semaforo di conteggio. (Ereditato da Object) |
| ToString() |
Restituisce una rappresentazione di stringa dell'oggetto. (Ereditato da Object) |
| TryAcquire() |
Acquisisce un permesso da questo semaforo, solo se ne è disponibile uno al momento della chiamata. |
| TryAcquire(Int32, Int64, TimeUnit) |
Acquisisce il numero specificato di permessi da questo semaforo, se tutti diventano disponibili entro il tempo di attesa specificato e il thread corrente non è stato interrotto da Thread#interrupt. |
| TryAcquire(Int32) |
Acquisisce il numero specificato di permessi da questo semaforo, solo se tutti sono disponibili al momento della chiamata. |
| TryAcquire(Int64, TimeUnit) |
Acquisisce un permesso da questo semaforo, se uno diventa disponibile entro il tempo di attesa specificato e il thread corrente non è stato interrotto Thread#interrupt. |
| UnregisterFromRuntime() |
Semaforo di conteggio. (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() |
Semaforo di conteggio. (Ereditato da Object) |
| IJavaPeerable.DisposeUnlessReferenced() |
Semaforo di conteggio. (Ereditato da Object) |
| IJavaPeerable.Finalized() |
Semaforo di conteggio. (Ereditato da Object) |
| IJavaPeerable.JniManagedPeerState |
Semaforo di conteggio. (Ereditato da Object) |
| IJavaPeerable.SetJniIdentityHashCode(Int32) |
Semaforo di conteggio. (Ereditato da Object) |
| IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates) |
Semaforo di conteggio. (Ereditato da Object) |
| IJavaPeerable.SetPeerReference(JniObjectReference) |
Semaforo di conteggio. (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) |
Semaforo di conteggio. |
| TryJavaCast<TResult>(IJavaPeerable, TResult) |
Provare a digitare |