ICondition.AwaitUntil(Date) Méthode

[Android.Runtime.Register("awaitUntil", "(Ljava/util/Date;)Z", "GetAwaitUntil_Ljava_util_Date_Handler:Java.Util.Concurrent.Locks.IConditionInvoker, Mono.Android, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null")]
public bool AwaitUntil(Java.Util.Date? deadline);

[<Android.Runtime.Register("awaitUntil", "(Ljava/util/Date;)Z", "GetAwaitUntil_Ljava_util_Date_Handler:Java.Util.Concurrent.Locks.IConditionInvoker, Mono.Android, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null")>]
abstract member AwaitUntil : Java.Util.Date -> bool

Paramètres

Retours

false si l’échéance s’est écoulée lors du retour, sinon true

Attributs

RegisterAttribute

Exceptions

Remarques

Provoque l’attente du thread actuel jusqu’à ce qu’il soit signalé ou interrompu, ou que l’échéance spécifiée 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 que 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>L’échéance spécifiée 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 valeur de retour indique si l’échéance s’est écoulée, qui peut être utilisée comme suit :

{@code
            boolean aMethod(Date deadline)
                throws InterruptedException {
              boolean stillWaiting = true;
              lock.lock();
              try {
                while (!conditionBeingWaitedFor()) {
                  if (!stillWaiting)
                    return false;
                  stillWaiting = theCondition.awaitUntil(deadline);
                }
                // ...
                return true;
              } finally {
                lock.unlock();
              }
            }}

<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 le passage de l’échéance spécifiée. 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.awaitUntil(java.util.Date).

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.