ICondition.AwaitNanos(Int64) Metodo

Riferimento

Definizione

Spazio dei nomi:: Java.Util.Concurrent.Locks

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.

Fa sì che il thread corrente attenda finché non viene segnalato o interrotto o trascorso il tempo di attesa specificato.

[Android.Runtime.Register("awaitNanos", "(J)J", "GetAwaitNanos_JHandler:Java.Util.Concurrent.Locks.IConditionInvoker, Mono.Android, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null")]
public long AwaitNanos (long nanosTimeout);

[<Android.Runtime.Register("awaitNanos", "(J)J", "GetAwaitNanos_JHandler:Java.Util.Concurrent.Locks.IConditionInvoker, Mono.Android, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null")>]
abstract member AwaitNanos : int64 -> int64

Parametri

nanosTimeout: Int64

tempo massimo di attesa, in nanosecondi

Restituisce

Int64

stima del nanosTimeout valore meno il tempo impiegato in attesa al ritorno da questo metodo. Un valore positivo può essere utilizzato come argomento per una chiamata successiva a questo metodo per terminare l'attesa del tempo desiderato. Un valore minore o uguale a zero indica che non rimane tempo.

Attributi: RegisterAttribute

Eccezioni

InterruptedException

se il thread corrente viene interrotto (e l'interruzione della sospensione del thread è supportata)

Commenti

Fa sì che il thread corrente attenda finché non viene segnalato o interrotto o trascorso il tempo di attesa specificato.

Il blocco associato a questa condizione viene rilasciato in modo atomico e il thread corrente viene disabilitato per scopi di pianificazione dei thread e giace inattivo fino a <quando non si verifica em>uno</em> di cinque cose: <ul><li>Altri thread richiamano il #signal metodo per questo Condition e il thread corrente viene scelto come thread da risvegliare; o <li>Altri thread richiamano il #signalAll metodo per questo Condition; o li><È supportato un altro thread Thread#interrupt che interrompe il thread corrente e l'interruzione della sospensione del thread; o <li>Il tempo di attesa specificato è trascorso; o <li>A "<si verifica la>riattivazione</em"> spurio. </ul>

In tutti i casi, prima che questo metodo possa restituire il thread corrente deve acquisire nuovamente il blocco associato a questa condizione. Quando il thread restituisce è <>garantito</em> per contenere questo blocco.

Se il thread corrente: <ul><li>ha lo stato interrotto impostato sulla voce di questo metodo; o <li>è Thread#interrupt interrotto durante l'attesa e l'interruzione della sospensione del thread è supportato, </ul>InterruptedException viene generato e lo stato interrotto del thread corrente viene cancellato. Non viene specificato, nel primo caso, indipendentemente dal fatto che il test per l'interruzione si verifichi prima del rilascio del blocco.

Il metodo restituisce una stima del numero di nanosecondi rimanenti per attendere il valore fornito nanosTimeout al momento della restituzione oppure un valore minore o uguale a zero se si è timeout. Questo valore può essere usato per determinare se e per quanto tempo attendere di nuovo nei casi in cui l'attesa restituisce ma una condizione attesa non è ancora in attesa. Gli usi tipici di questo metodo hanno il formato seguente:

{@code
            boolean aMethod(long timeout, TimeUnit unit)
                throws InterruptedException {
              long nanosRemaining = unit.toNanos(timeout);
              lock.lock();
              try {
                while (!conditionBeingWaitedFor()) {
                  if (nanosRemaining <= 0L)
                    return false;
                  nanosRemaining = theCondition.awaitNanos(nanosRemaining);
                }
                // ...
                return true;
              } finally {
                lock.unlock();
              }
            }}

Nota di progettazione: questo metodo richiede un argomento nanosecondo per evitare errori di troncamento nella segnalazione dei tempi rimanenti. Tale perdita di precisione renderebbe difficile per i programmatori garantire che i tempi di attesa totali non siano sistematicamente più brevi di quanto specificato quando si verificano ri-attese.

<b>Considerazioni sull'implementazione</b>

Si presuppone che il thread corrente contenga il blocco associato a questo Condition quando viene chiamato questo metodo. Spetta all'implementazione determinare se questo è il caso e, in caso contrario, come rispondere. In genere, verrà generata un'eccezione ( ad esempio IllegalMonitorStateException) e l'implementazione deve documentare tale fatto.

Un'implementazione può favorire la risposta a un interrupt rispetto al normale metodo restituito in risposta a un segnale o a un over che indica la scadenza del tempo di attesa specificato. In entrambi i casi l'implementazione deve assicurarsi che il segnale venga reindirizzato a un altro thread in attesa, se presente.

Documentazione java per java.util.concurrent.locks.Condition.awaitNanos(long).

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dal progetto Open Source Android e usato in base ai termini descritti nella licenza Creative Commons 2.5 Attribuzione.

Si applica a

Condividi tramite