ICondition.AwaitNanos(Int64) Método

[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

Retornos

uma estimativa do nanosTimeout valor menos o tempo gasto aguardando no retorno desse método. Um valor positivo pode ser usado como o 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 há tempo restante.

Atributos

RegisterAttribute

Exceções

Comentários

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

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 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 issoCondition; ou li><Alguns outros threads#interrupt interrompem o thread atual e há suporte para a interrupção da suspensão de thread; ou <li>O tempo de espera especificado decorrido; ou <li>A "<ocorre em>wakeup</em>" espúrio. </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, ele é <>garantido</em> para manter esse bloqueio.

Se o thread atual: <ul><li>tem seu status interrompido definido na entrada para este método; ou <li>é thread#interrupção interrompida enquanto espera e interrupção da suspensão de thread é suportado, </ul> então InterruptedException é gerado e o status interrompido do thread atual é limpo. Não é especificado, no primeiro caso, se o teste para interrupção ocorre ou não antes do bloqueio ser liberado.

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 atingiu o tempo limite. Esse valor pode ser usado para determinar se e quanto tempo aguardar novamente nos casos em que a espera retorna, mas uma condição aguardada ainda não é retenção. Os usos típicos desse método tomam o seguinte formulário:

{@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();
              }
            }}

Observação de design: esse método requer um argumento nanossegundo para evitar erros de truncamento no relatório dos tempos restantes. Essa perda de precisão dificultaria que os programadores garantissem que os tempos de espera totais não sejam sistematicamente menores do que o especificado quando ocorrerem novas esperas.

<b>Considerações< de implementação/b>

Supõe-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, se não, como responder. Normalmente, uma exceção será gerada (como IllegalMonitorStateException) e a implementação deve documentar esse fato.

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

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 usadas de acordo com os termos descritos na Licença de Atribuição Creative Commons 2.5.