ICondition.AwaitUntil(Date) Method

Reference

Definition

Namespace:: Java.Util.Concurrent.Locks

Assembly:: Mono.Android.dll

Important

Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.

Causes the current thread to wait until it is signalled or interrupted, or the specified deadline elapses.

[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

Parameters

deadline: Date

the absolute time to wait until

Returns

Boolean

false if the deadline has elapsed upon return, else true

Attributes: RegisterAttribute

Exceptions

InterruptedException

if the current thread is interrupted (and interruption of thread suspension is supported)

Remarks

Causes the current thread to wait until it is signalled or interrupted, or the specified deadline elapses.

The lock associated with this condition is atomically released and the current thread becomes disabled for thread scheduling purposes and lies dormant until one of five things happens: <ul> <li>Some other thread invokes the #signal method for this Condition and the current thread happens to be chosen as the thread to be awakened; or <li>Some other thread invokes the #signalAll method for this Condition; or <li>Some other thread Thread#interrupt interrupts the current thread, and interruption of thread suspension is supported; or <li>The specified deadline elapses; or <li>A "spurious wakeup" occurs. </ul>

In all cases, before this method can return the current thread must re-acquire the lock associated with this condition. When the thread returns it is guaranteed to hold this lock.

If the current thread: <ul> <li>has its interrupted status set on entry to this method; or <li>is Thread#interrupt interrupted while waiting and interruption of thread suspension is supported, </ul> then InterruptedException is thrown and the current thread's interrupted status is cleared. It is not specified, in the first case, whether or not the test for interruption occurs before the lock is released.

The return value indicates whether the deadline has elapsed, which can be used as follows:

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

Implementation Considerations

The current thread is assumed to hold the lock associated with this Condition when this method is called. It is up to the implementation to determine if this is the case and if not, how to respond. Typically, an exception will be thrown (such as IllegalMonitorStateException) and the implementation must document that fact.

An implementation can favor responding to an interrupt over normal method return in response to a signal, or over indicating the passing of the specified deadline. In either case the implementation must ensure that the signal is redirected to another waiting thread, if there is one.

Java documentation for java.util.concurrent.locks.Condition.awaitUntil(java.util.Date).

Portions of this page are modifications based on work created and shared by the Android Open Source Project and used according to terms described in the Creative Commons 2.5 Attribution License.

Applies to

Share via