ICondition.AwaitNanos(Int64) Método

Referência

Definição

Namespace:: Java.Util.Concurrent.Locks

Assembly:: Mono.Android.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Faz com que o thread atual aguarde até que seja sinalizado ou interrompido ou o tempo de espera especificado decorra.

[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

Parâmetros

nanosTimeout: Int64

O tempo máximo de espera, em nanossegundos

Retornos

Int64

uma estimativa do nanosTimeout valor menos o tempo gasto aguardando no retorno desse método. Um valor positivo pode ser usado como argumento para uma chamada subsequente a esse método para concluir a espera do tempo desejado. Um valor menor ou igual a zero indica que não resta tempo.

Atributos: RegisterAttribute

Exceções

InterruptedException

se o thread atual for interrompido (e a interrupção da suspensão do thread for suportada)

Comentários

Faz com que o thread atual aguarde até que seja sinalizado ou interrompido ou o tempo de espera especificado decorra.

O bloqueio associado a essa condição é liberado atomicamente e o thread atual fica desabilitado para fins de agendamento de thread e fica inativo até <que em>um</em> de cinco coisas aconteça: <ul<>li>Algum outro thread invoca o #signal método para isso Condition e o thread atual passa a ser escolhido como o thread a ser despertado; ou <li>Algum outro thread invoca o #signalAll método para isso;<> ConditionAlgum outro thread Thread#interrupt interrompe o thread atual e a interrupção da suspensão do thread é suportada; ou <li>O tempo de espera especificado decorre; ou <li>A "<em>despertar< espúrio/em>" ocorre. </ul>

Em todos os casos, antes que esse método possa retornar o thread atual deve adquirir novamente o bloqueio associado a essa condição. Quando o thread retorna é <garantido></em> para segurar este bloqueio.

Se o thread atual: <ul><li>tiver seu status interrompido definido na entrada deste método, ou <li>for Thread#interrupt interrompido enquanto aguarda e a interrupção da suspensão do thread for suportada, </ul> então InterruptedException será lançado e o status interrompido do thread atual será limpo. Não é especificado, no primeiro caso, se o teste de interrupção ocorre ou não antes da liberação do bloqueio.

O método retorna uma estimativa do número de nanossegundos restantes para aguardar dado o valor fornecido nanosTimeout no retorno, ou um valor menor ou igual a zero se ele expirou. Esse valor pode ser usado para determinar se e quanto tempo esperar novamente nos casos em que a espera retorna, mas uma condição aguardada ainda não se mantém. Os usos típicos desse método assumem a seguinte forma:

{@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 de design: Este método requer um argumento de nanossegundos para evitar erros de truncamento no relatório de tempos restantes. Essa perda de precisão tornaria difícil para os programadores garantir que os tempos totais de espera não sejam sistematicamente mais curtos do que o especificado quando ocorrem novas esperas.

<b>Considerações< sobre a implementação/b>

Presume-se que o thread atual mantenha o bloqueio associado a isso Condition quando esse método é chamado. Cabe à implementação determinar se esse é o caso e, em caso negativo, como responder. Normalmente, uma exceção será lançada (como IllegalMonitorStateException) e a implementação deve documentar esse fato.

Uma implementação pode favorecer a resposta a uma interrupção em vez do retorno do método normal em resposta a um sinal, ou sobre a indicação do tempo de espera especificado. Em ambos os casos, a implementação deve garantir que o sinal seja redirecionado para outro thread em espera, se houver.

Documentação Java para java.util.concurrent.locks.Condition.awaitNanos(long).

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Android Open Source Project e usado de acordo com os termos descritos na Creative Commons 2.5 Attribution License.

Aplica-se a

Compartilhar via