ICondition.AwaitNanos(Int64) Méthode

[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

Paramètres

Retours

estimation de la nanosTimeout valeur moins le temps passé en attente à partir de cette méthode. Une valeur positive peut être utilisée comme argument d’un appel ultérieur à cette méthode pour terminer l’attente de l’heure souhaitée. Une valeur inférieure ou égale à zéro indique qu’aucun temps n’est conservé.

Attributs

RegisterAttribute

Exceptions

Remarques

Provoque l’attente du thread actuel jusqu’à ce qu’il soit signalé ou interrompu, ou que le temps d’attente spécifié s’écoule.

Le verrou associé à cette condition est libéré atomiquement et le thread actuel devient désactivé à des fins de planification de threads et se trouve dormant jusqu’à <ce qu’em one</em>> de cinq choses se produisent : <ul><li>Li Un autre thread appelle la #signal méthode pour cela Condition et le thread actuel est choisi comme thread à réveiller ; ou <li>Un autre thread appelle la #signalAll méthode pour cela Condition; ou <li li>D’autres threads thread#interruption interrompent le thread actuel et l’interruption de la suspension de thread est prise en charge ; ou <li>Le temps d’attente spécifié s’écoule ; ou <li>A "<em>spurious wakeup</em>" se produit. </ul>

Dans tous les cas, avant que cette méthode puisse retourner le thread actuel, vous devez réinscrire le verrou associé à cette condition. Lorsque le thread retourne, il est <garanti></em> de contenir ce verrou.

Si le thread actuel : <ul><li>a son état interrompu défini sur l’entrée de cette méthode ; ou <li>est interruption thread#interruption lors de l’attente et l’interruption de la suspension de thread est prise en charge, </ul> est levée et InterruptedException l’état interrompu du thread actuel est effacé. Elle n’est pas spécifiée, dans le premier cas, si le test d’interruption se produit avant la libération du verrou.

La méthode retourne une estimation du nombre de nanosecondes restant à attendre en fonction de la valeur fournie nanosTimeout lors du retour, ou d’une valeur inférieure ou égale à zéro si elle a expiré. Cette valeur peut être utilisée pour déterminer si et la durée d’attente dans les cas où l’attente retourne, mais une condition attendue ne tient toujours pas. Les utilisations classiques de cette méthode prennent la forme suivante :

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

Remarque de conception : cette méthode nécessite un argument nanoseconde afin d’éviter les erreurs de troncation dans le rapport des heures restantes. Une telle perte de précision rendait difficile pour les programmeurs de s’assurer que les temps d’attente totaux ne sont pas systématiquement plus courts que spécifiés lorsque des nouvelles attentes se produisent.

<b>Considérations relatives< à l’implémentation/b>

Le thread actuel est supposé contenir le verrou associé à cette Condition méthode lorsque cette méthode est appelée. Il incombe à l’implémentation de déterminer si c’est le cas et si ce n’est pas le cas, comment répondre. En règle générale, une exception est levée (par exemple IllegalMonitorStateException) et l’implémentation doit documenter ce fait.

Une implémentation peut favoriser la réponse à une interruption par rapport à une méthode normale en réponse à un signal, ou indiquer l’expiration du délai d’attente spécifié. Dans les deux cas, l’implémentation doit s’assurer que le signal est redirigé vers un autre thread en attente, s’il en existe un.

Documentation Java pour java.util.concurrent.locks.Condition.awaitNanos(long).

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

S’applique à