ICondition 接口

定义

命名空间:: Java.Util.Concurrent.Locks

程序集:: Mono.Android.dll

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

Condition将Object监视器方法（Object#wait() waitObject#notify notify和Object#notifyAll notifyAll）分解为不同的对象，以便通过将多个等待集与任意Lock实现结合使用，使每个对象具有多个等待集的效果。

[Android.Runtime.Register("java/util/concurrent/locks/Condition", "", "Java.Util.Concurrent.Locks.IConditionInvoker")]
public interface ICondition : Android.Runtime.IJavaObject, IDisposable, Java.Interop.IJavaPeerable

[<Android.Runtime.Register("java/util/concurrent/locks/Condition", "", "Java.Util.Concurrent.Locks.IConditionInvoker")>]
type ICondition = interface
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable

派生: Java.Util.Concurrent.Locks.AbstractQueuedLongSynchronizer.ConditionObject

Java.Util.Concurrent.Locks.AbstractQueuedSynchronizer.ConditionObject

属性: RegisterAttribute

实现: IJavaObject IJavaPeerable IDisposable

注解

Condition将Object监视器方法（Object#wait() waitObject#notify notify和Object#notifyAll notifyAll）分解为不同的对象，以便通过将多个等待集与任意Lock实现结合使用，使每个对象具有多个等待集的效果。如果替换 Lock 方法和语句的使用 synchronized ，则 Condition 替换对象监视器方法的使用。

条件（也称为 <em>条件队列</em> 或 <em>条件变量</em>）为一个线程提供暂停执行的方法（到 ”wait“）直到另一个线程通知，某些状态条件现在可能为 true。由于对此共享状态信息的访问发生在不同的线程中，因此必须对其进行保护，因此某种形式的锁与条件相关联。等待条件提供的键属性是，它以原子方式/em< 释放关联的锁并挂起当前线程，就像>。<>Object.wait

Condition实例本质上绑定到锁。若要获取 Condition 特定 Lock 实例的实例，请使用其 Lock#newCondition newCondition() 方法。

例如，假设我们有一个支持和put方法的绑定缓冲区take。如果在空缓冲区上尝试 a take ，则线程将阻塞，直到某个项可用;如果在完整缓冲区上尝试某个 put 项，则线程将阻塞，直到空间可用。我们希望将等待线程和put线程保留在单独的等待take集中，以便我们可以在缓冲区中可用项或空间时只通知单个线程的优化。这可以使用两 Condition 个实例来实现。

class BoundedBuffer&lt;E&gt; {
<b>final Lock lock = new ReentrantLock();</b>
              final Condition notFull  = <b>lock.newCondition(); </b>
              final Condition notEmpty = <b>lock.newCondition(); </b>

              final Object[] items = new Object[100];
              int putptr, takeptr, count;

              public void put(E x) throws InterruptedException {
<b>lock.lock();
                try {</b>
                  while (count == items.length)
<b>notFull.await();</b>
                  items[putptr] = x;
                  if (++putptr == items.length) putptr = 0;
                  ++count;
<b>notEmpty.signal();</b>
<b>} finally {
                  lock.unlock();
                }</b>
              }

              public E take() throws InterruptedException {
<b>lock.lock();
                try {</b>
                  while (count == 0)
<b>notEmpty.await();</b>
                  E x = (E) items[takeptr];
                  if (++takeptr == items.length) takeptr = 0;
                  --count;
<b>notFull.signal();</b>
                  return x;
<b>} finally {
                  lock.unlock();
                }</b>
              }
            }

（该 java.util.concurrent.ArrayBlockingQueue 类提供此功能，因此没有理由实现此示例用法类。

Condition实现可以提供的行为和语义，这些行为和语义不同于监视方法的行为Object和语义，例如通知的有保证顺序，或者不需要在执行通知时保留锁。如果实现提供此类专用语义，则实现必须记录这些语义。

请注意， Condition 实例只是普通对象，可以自己用作语句中的 synchronized 目标，并且可以调用自己的监视器 Object#wait wait 和 Object#notify notify 方法。获取实例的 Condition 监视器锁或使用其监视方法没有与获取 Lock 与之 Condition 关联的关联或使用其 #await 等待和 #signal 信号方法的指定关系。建议避免混淆，除非在自己的实现中，否则绝不会以这种方式使用 Condition 实例。

除非有注释，否则 null 为任何参数传递值将导致 NullPointerException 引发。

<h2>实现注意事项</h2>

等待 a Condition时， a ”<>通常，允许将虚假唤醒</em>“ 作为基础平台语义的让步进行。这对大多数应用程序程序的影响不大，因为 Condition 应该始终在循环中等待，测试正在等待的状态谓词。实现可以自由地消除虚假唤醒的可能性，但建议应用程序程序员始终假设它们可能发生，因此始终在循环中等待。

三种形式的条件等待（可中断、不可中断和计时）在一些平台上的轻松实现以及性能特征可能有所不同。具体而言，提供这些功能并维护特定的语义（如排序保证）可能很困难。此外，中断线程的实际挂起的能力并不总是可行，在所有平台上实现。

因此，实现不需要为所有三种形式的等待定义完全相同的保证或语义，也不需要支持中断线程的实际挂起。

实现需要清楚地记录每个等待方法提供的语义和保证，当实现支持线程挂起中断时，它必须遵守此接口中定义的中断语义。

由于中断通常意味着取消，并且检查中断通常是不频繁的，因此实现可以倾向于响应中断，而正常方法返回。即使可以表明中断发生在可能已解除阻止线程的另一个操作之后，也是如此。实现应记录此行为。

在 1.5 中添加。

Java文档java.util.concurrent.locks.Condition。

本页的某些部分是根据创建和共享的工作进行的修改，并根据许可证中所述的条款使用。

属性

名称	说明
Handle	获取基础 Android 对象的 JNI 值。 (继承自 IJavaObject)
JniIdentityHashCode	返回包装实例的值 `java.lang.System.identityHashCode()` 。 (继承自 IJavaPeerable)
JniManagedPeerState	托管对等方的状态。 (继承自 IJavaPeerable)
JniObjectReferenceControlBlock	`Condition`将`Object`监视器方法（`Object#wait() waitObject#notify notify`和`Object#notifyAll notifyAll`）分解为不同的对象，以便通过将多个等待集与任意`Lock`实现结合使用，使每个对象具有多个等待集的效果。 (继承自 IJavaPeerable)
JniPeerMembers	成员访问和调用支持。 (继承自 IJavaPeerable)
PeerReference	返回JniObjectReference包装的Java对象实例。 (继承自 IJavaPeerable)

方法

名称	说明
Await()	导致当前线程等待，直到发出信号或 Thread#中断中断。
Await(Int64, TimeUnit)	使当前线程等待，直到发出信号或中断，或指定的等待时间已过。
AwaitNanos(Int64)	使当前线程等待，直到发出信号或中断，或指定的等待时间已过。
AwaitUninterruptibly()	使当前线程等待，直到发出信号。
AwaitUntil(Date)	使当前线程等待，直到发出信号或中断，或指定的截止时间结束。
Disposed()	在释放实例时调用。 (继承自 IJavaPeerable)
DisposeUnlessReferenced()	如果没有对此实例的未完成引用，则调用 `Dispose()`;否则不执行任何操作。 (继承自 IJavaPeerable)
Finalized()	在实例完成时调用。 (继承自 IJavaPeerable)
SetJniIdentityHashCode(Int32)	设置由 `JniIdentityHashCode`. 返回的值。 (继承自 IJavaPeerable)
SetJniManagedPeerState(JniManagedPeerStates)	`Condition`将`Object`监视器方法（`Object#wait() waitObject#notify notify`和`Object#notifyAll notifyAll`）分解为不同的对象，以便通过将多个等待集与任意`Lock`实现结合使用，使每个对象具有多个等待集的效果。 (继承自 IJavaPeerable)
SetPeerReference(JniObjectReference)	设置由 `PeerReference`. 返回的值。 (继承自 IJavaPeerable)
Signal()	唤醒一个等待线程。
SignalAll()	唤醒所有等待的线程。
UnregisterFromRuntime()	取消注册此实例，使运行时不会从将来 Java.Interop.JniRuntime+JniValueManager.PeekValue 的调用中返回它。 (继承自 IJavaPeerable)

扩展方法

名称	说明
GetJniTypeName(IJavaPeerable)	获取实例 `self`类型的 JNI 名称。
JavaAs<TResult>(IJavaPeerable)	尝试强制`self`键入`TResult`，检查强制是否在Java端有效。
JavaCast<TResult>(IJavaObject)	执行 Android 运行时检查的类型转换。
JavaCast<TResult>(IJavaObject)	`Condition`将`Object`监视器方法（`Object#wait() waitObject#notify notify`和`Object#notifyAll notifyAll`）分解为不同的对象，以便通过将多个等待集与任意`Lock`实现结合使用，使每个对象具有多个等待集的效果。
TryJavaCast<TResult>(IJavaPeerable, TResult)	尝试强制`self`键入`TResult`，检查强制是否在Java端有效。

适用于