ICondition 接口

定义

[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() 方法。

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

class BoundedBuffer<E> {
<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。

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