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. Se un Lock oggetto sostituisce l'uso di synchronized metodi e istruzioni, sostituisce Condition l'uso dei metodi di monitoraggio object.
Condizioni (note anche come <code> di condizioni em</em> o <variabili> di condizione em</em>) forniscono un mezzo per un thread per sospendere l'esecuzione (a " wait") 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, pertanto un blocco di una maschera è associato alla condizione. La proprietà chiave che in attesa di una condizione fornisce è che <em in>modo atomico</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 Condition di per una determinata Lock istanza, utilizzare il relativo Lock#newCondition newCondition() metodo.
Si supponga, ad esempio, di avere un buffer delimitato che supporta put i metodi e take . Se si tenta di eseguire un take tentativo in un buffer vuoto, il thread bloccherà fino a quando non diventa disponibile un elemento. Se put si tenta di eseguire un tentativo su un buffer completo, il thread bloccherà fino a quando non diventa disponibile uno spazio. Si desidera mantenere i thread e put i thread in attesa take in set di attesa separati, in modo da poter usare l'ottimizzazione della notifica di un singolo thread alla volta in cui gli elementi o gli spazi diventano disponibili nel buffer. A tale scopo, è possibile usare 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 Object delle notifiche. Se un'implementazione fornisce una semantica così 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 un 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 relativi metodi di monitoraggio non ha alcuna relazione specificata con l'acquisizione dell'oggetto associato a tale Lock oggetto o all'uso Condition del relativo #await metodi di attesa e #signal segnalazione. È consigliabile evitare confusione che non si usino Condition mai istanze in questo modo, tranne forse all'interno della propria implementazione.
Se non specificato, il passaggio di un null valore per qualsiasi parametro comporterà la creazione di un'eccezione NullPointerException .
<Considerazioni sull'implementazione> h2</h2>
In attesa di un Conditionoggetto , un "<em>spurious wakeup</em>" è autorizzato a verificarsi, in generale, come concessione alla semantica della piattaforma sottostante. Questo ha un impatto poco pratico sulla maggior parte dei programmi dell'applicazione perché 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 (interrompibili, non interrompibili e a tempo) possono differire nella facilità di implementazione in alcune piattaforme e nelle relative caratteristiche di prestazioni. In particolare, può essere difficile fornire queste funzionalità e mantenere una semantica specifica, ad esempio le garanzie di ordinamento. Inoltre, la possibilità di interrompere la sospensione effettiva del thread potrebbe non essere sempre fattibile da 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 rispettare la semantica di interruzione come definito in questa interfaccia.
Poiché l'interruzione implica in genere l'annullamento e i controlli per l'interruzione sono spesso poco frequenti, un'implementazione può favorire la risposta a un interrupt rispetto alla restituzione normale del metodo. Questo vale anche se può essere mostrato che l'interrupt si è verificato dopo un'altra azione che potrebbe aver sbloccato il thread. Un'implementazione deve documentare questo comportamento.
Aggiunto nella versione 1.5.
per java.util.concurrent.locks.Condition.
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.
Proprietà
| Nome | Descrizione |
|---|---|
| Handle |
Ottiene il valore JNI dell'oggetto Android sottostante. (Ereditato da IJavaObject) |
| JniIdentityHashCode |
Restituisce il valore di |
| JniManagedPeerState |
Stato del peer gestito. (Ereditato da IJavaPeerable) |
| JniPeerMembers |
Supporto per l'accesso ai membri e la chiamata. (Ereditato da IJavaPeerable) |
| PeerReference |
Restituisce un JniObjectReference oggetto dell'istanza dell'oggetto di cui è stato eseguito il wrapping Java. (Ereditato da IJavaPeerable) |
Metodi
| Nome | Descrizione |
|---|---|
| Await() |
Fa sì che il thread corrente attenda finché non viene segnalato o thread#interrupt interrotto. |
| Await(Int64, TimeUnit) |
Fa sì che il thread corrente attenda finché non viene segnalato o interrotto o trascorso il tempo di attesa specificato. |
| AwaitNanos(Int64) |
Fa sì che il thread corrente attenda finché non viene segnalato o interrotto o trascorso il tempo di attesa specificato. |
| AwaitUninterruptibly() |
Fa sì che il thread corrente attenda finché non viene segnalato. |
| AwaitUntil(Date) |
Fa in modo che il thread corrente attenda finché non viene segnalato o interrotto o scade la scadenza specificata. |
| 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 restituisca dalle chiamate future Java.Interop.JniRuntime+JniValueManager.PeekValue . (Ereditato da IJavaPeerable) |
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) |
|
| TryJavaCast<TResult>(IJavaPeerable, TResult) |
Provare a digitare |