ICondition Interfaccia
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.
Conditionfattori i Object metodi di monitoraggio (Object#wait() waitObject#notify notifye Object#notifyAll notifyAll) in oggetti distinti per dare l'effetto di avere più set di attesa per oggetto, combinandoli con l'uso di implementazioni arbitrarieLock.
[Android.Runtime.Register("java/util/concurrent/locks/Condition", "", "Java.Util.Concurrent.Locks.IConditionInvoker")]
public interface ICondition : Android.Runtime.IJavaObject, IDisposable, Java.Interop.IJavaPeerable[<Android.Runtime.Register("java/util/concurrent/locks/Condition", "", "Java.Util.Concurrent.Locks.IConditionInvoker")>]
type ICondition = interface
interface IJavaObject
interface IDisposable
interface IJavaPeerable- Derivato
- Attributi
- Implementazioni
Commenti
Conditionfattori i Object metodi di monitoraggio (Object#wait() waitObject#notify notifye Object#notifyAll notifyAll) in oggetti distinti per dare l'effetto di avere più set di attesa per oggetto, combinandoli con l'uso di implementazioni arbitrarieLock. In cui un Lock sostituisce l'uso di metodi e istruzioni, un Condition sostituisce l'uso dei synchronized metodi di monitoraggio oggetto.
Le condizioni (note anche come <code em>condition queue</em> o <em condition variables</em>>) forniscono un mezzo per un thread per sospendere l'esecuzione (per " attendere") fino a quando non viene notificata da un altro thread che alcune condizioni di stato potrebbero ora essere vere. Poiché l'accesso a queste informazioni sullo stato condiviso si verifica in thread diversi, deve essere protetto, quindi un blocco di un modulo è associato alla condizione. La proprietà chiave che in attesa di una condizione fornisce è che em em atomicamente</em>> rilascia il blocco associato e sospende il thread corrente, proprio come Object.wait.<
Un'istanza Condition è intrinsecamente associata a un blocco. Per ottenere un'istanza per un'istanza Condition specifica Lock , usare il Lock#newCondition newCondition() relativo metodo.
Si supponga, ad esempio, di avere un buffer delimitato che supporta put e take metodi. Se un take tentativo viene eseguito su un buffer vuoto, il thread blocca fino a quando non diventa disponibile un elemento. Se un put tentativo viene eseguito su un buffer completo, il thread blocca fino a quando non diventa disponibile uno spazio. Si desidera mantenere put i thread e take i thread in attesa in set di attesa separati in modo che sia possibile usare l'ottimizzazione solo per notificare un singolo thread alla volta quando gli elementi o gli spazi diventano disponibili nel buffer. Ciò può essere ottenuto usando due Condition istanze.
class BoundedBuffer<E> {
<b>final Lock lock = new ReentrantLock();</b>
final Condition notFull = <b>lock.newCondition(); </b>
final Condition notEmpty = <b>lock.newCondition(); </b>
final Object[] items = new Object[100];
int putptr, takeptr, count;
public void put(E x) throws InterruptedException {
<b>lock.lock();
try {</b>
while (count == items.length)
<b>notFull.await();</b>
items[putptr] = x;
if (++putptr == items.length) putptr = 0;
++count;
<b>notEmpty.signal();</b>
<b>} finally {
lock.unlock();
}</b>
}
public E take() throws InterruptedException {
<b>lock.lock();
try {</b>
while (count == 0)
<b>notEmpty.await();</b>
E x = (E) items[takeptr];
if (++takeptr == items.length) takeptr = 0;
--count;
<b>notFull.signal();</b>
return x;
<b>} finally {
lock.unlock();
}</b>
}
}
La java.util.concurrent.ArrayBlockingQueue classe fornisce questa funzionalità, pertanto non esiste alcun motivo per implementare questa classe di utilizzo di esempio.
Un'implementazione Condition può fornire un comportamento e una semantica diversa da quella dei metodi di monitoraggio, ad esempio l'ordinamento garantito per le notifiche o la mancata esecuzione di un blocco durante l'esecuzione delle Object notifiche. Se un'implementazione fornisce una semantica specializzata, l'implementazione deve documentare tali semantiche.
Si noti che Condition le istanze sono solo oggetti normali e possono essere usate come destinazione in un'istruzione synchronized e possono avere il proprio monitoraggio Object#wait wait e Object#notify notify metodi richiamati. L'acquisizione del blocco di monitoraggio di un'istanza Condition o l'uso dei metodi di monitoraggio non ha alcuna relazione specificata con l'acquisizione dell'oggetto associato Condition o l'uso Lock del relativo #await metodi di attesa e #signal segnalazione. È consigliabile evitare confusione che non usi Condition mai istanze in questo modo, tranne forse all'interno della propria implementazione.
Tranne dove indicato, passando un null valore per qualsiasi parametro verrà NullPointerException generato.
<h2 Considerazioni sull'implementazione</h2>>
Quando è in attesa di Condition, una citazione &;<em>spurious wakeup</em>" è consentito verificarsi, in generale, come concessione alla semantica della piattaforma sottostante. Questo ha un impatto poco pratico sulla maggior parte dei programmi dell'applicazione come Condition deve essere sempre aspettato in un ciclo, testando il predicato di stato che è in attesa. Un'implementazione è libera di rimuovere la possibilità di riattivazioni spurie, ma è consigliabile che i programmatori di applicazioni presuppongono sempre che possano verificarsi e quindi attendere sempre in un ciclo.
Le tre forme di attesa delle condizioni (interruzioni, non interruzioni e timed) possono variare nella loro facilità di implementazione in alcune piattaforme e nelle loro caratteristiche di prestazioni. In particolare, potrebbe essere difficile fornire queste funzionalità e mantenere semantiche specifiche, ad esempio le garanzie di ordinamento. Inoltre, la possibilità di interrompere la sospensione effettiva del thread potrebbe non essere sempre possibile implementare su tutte le piattaforme.
Di conseguenza, un'implementazione non è necessaria per definire esattamente le stesse garanzie o semantiche per tutte e tre le forme di attesa, né è necessario supportare l'interruzione della sospensione effettiva del thread.
Un'implementazione è necessaria per documentare chiaramente la semantica e le garanzie fornite da ognuno dei metodi in attesa e quando un'implementazione supporta l'interruzione della sospensione del thread, deve obbedire alla semantica di interruzione definita in questa interfaccia.
Poiché l'interruzione implica in genere l'annullamento e i controlli per l'interruzione sono spesso infrequenti, un'implementazione può favorire la risposta a un interruzione rispetto alla restituzione normale del metodo. Questo è vero anche se può essere mostrato che l'interruzione si è verificata dopo un'altra azione che potrebbe aver sbloccato il thread. Un'implementazione deve documentare questo comportamento.
Aggiunto nella versione 1.5.
Documentazione Java per java.util.concurrent.locks.Condition.
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 .
Proprietà
| Handle |
Ottiene il valore JNI dell'oggetto Android sottostante. (Ereditato da IJavaObject) |
| JniIdentityHashCode |
Restituisce il valore di per |
| JniManagedPeerState |
Stato del peer gestito. (Ereditato da IJavaPeerable) |
| JniPeerMembers |
Supporto per l'accesso ai membri e la chiamata. (Ereditato da IJavaPeerable) |
| PeerReference |
Restituisce un'istanza JniObjectReference dell'oggetto Java con wrapping. (Ereditato da IJavaPeerable) |
Metodi
| Await() |
Causa l'interruzione del thread corrente fino a quando non viene segnalato o Thread#interrupt. |
| Await(Int64, TimeUnit) |
Causa l'attesa del thread corrente fino a quando non viene segnalato o interrotto o trascorso il tempo di attesa specificato. |
| AwaitNanos(Int64) |
Causa l'attesa del thread corrente fino a quando non viene segnalato o interrotto o trascorso il tempo di attesa specificato. |
| AwaitUninterruptibly() |
Causa l'attesa del thread corrente fino a quando non viene segnalato. |
| AwaitUntil(Date) |
Causa l'attesa del thread corrente fino a quando non viene segnalato o interrotto oppure la scadenza specificata viene trascorsa. |
| Disposed() |
Chiamato quando l'istanza è stata eliminata. (Ereditato da IJavaPeerable) |
| DisposeUnlessReferenced() |
Se non sono presenti riferimenti in sospeso a questa istanza, chiama |
| Finalized() |
Chiamato quando l'istanza è stata finalizzata. (Ereditato da IJavaPeerable) |
| SetJniIdentityHashCode(Int32) |
Impostare il valore restituito da |
| SetJniManagedPeerState(JniManagedPeerStates) |
|
| SetPeerReference(JniObjectReference) |
Impostare il valore restituito da |
| Signal() |
Riattiva un thread in attesa. |
| SignalAll() |
Riattiva tutti i thread in attesa. |
| UnregisterFromRuntime() |
Annullare la registrazione di questa istanza in modo che il runtime non lo restituirà dalle chiamate future Java.Interop.JniRuntime+JniValueManager.PeekValue . (Ereditato da IJavaPeerable) |
Metodi di estensione
| JavaCast<TResult>(IJavaObject) |
Esegue una conversione dei tipi controllati dal runtime Android. |
| JavaCast<TResult>(IJavaObject) |
|
| GetJniTypeName(IJavaPeerable) |
|