ICondition Interfaz
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Condition factoriza los métodos de Object supervisión (Object#wait() waity Object#notify notifyObject#notifyAll notifyAll) en objetos distintos para dar el efecto de tener varios conjuntos de espera por objeto, al combinarlos con el uso de implementaciones arbitrarias 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- Derivado
- Atributos
- Implementaciones
Comentarios
Condition factoriza los métodos de Object supervisión (Object#wait() waity Object#notify notifyObject#notifyAll notifyAll) en objetos distintos para dar el efecto de tener varios conjuntos de espera por objeto, al combinarlos con el uso de implementaciones arbitrarias Lock .
Lock Cuando reemplaza el uso de synchronized métodos e instrucciones , reemplaza Condition el uso de los métodos de supervisión de objetos.
Las condiciones (también conocidas como <>em condition queues/em< o >em<condition variables>/em<) proporcionan un medio para que un subproceso> suspenda la ejecución (a " wait") hasta que se notifique por otro subproceso, es posible que alguna condición de estado ahora sea verdadera. Dado que el acceso a esta información de estado compartido se produce en diferentes subprocesos, debe protegerse, por lo que un bloqueo de algún formulario está asociado a la condición. La propiedad de clave que espera una condición proporciona es que em <>de forma atómica</em> libera el bloqueo asociado y suspende el subproceso actual, al igual Object.waitque .
Una Condition instancia está enlazada intrínsecamente a un bloqueo. Para obtener una Condition instancia de para una instancia determinada Lock , use su Lock#newCondition newCondition() método .
Por ejemplo, supongamos que tenemos un búfer delimitado que admite put métodos y take .
take Si se intenta en un búfer vacío, el subproceso se bloqueará hasta que un elemento esté disponible; si put se intenta en un búfer completo, el subproceso se bloqueará hasta que haya un espacio disponible. Nos gustaría mantener en espera put subprocesos y take subprocesos en conjuntos de espera independientes para que podamos usar la optimización de notificar solo un único subproceso a la vez cuando los elementos o espacios estén disponibles en el búfer. Esto se puede lograr mediante dos Condition instancias.
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>
}
}
(La java.util.concurrent.ArrayBlockingQueue clase proporciona esta funcionalidad, por lo que no hay ninguna razón para implementar esta clase de uso de ejemplo).
Una Condition implementación puede proporcionar un comportamiento y una semántica diferentes de los Object métodos de supervisión, como la ordenación garantizada de las notificaciones, o no requerir que se mantenga un bloqueo al realizar notificaciones. Si una implementación proporciona esta semántica especializada, la implementación debe documentar esa semántica.
Tenga en cuenta que Condition las instancias son simplemente objetos normales y se pueden usar como destino en una synchronized instrucción y pueden tener su propio monitor Object#wait wait y Object#notify notify métodos invocados. La adquisición del bloqueo de monitor de una Condition instancia o el uso de sus métodos de supervisión, no tiene ninguna relación especificada con la adquisición del Lock asociado Condition o el uso de sus #await métodos de señalización en espera y #signal. Se recomienda evitar confusiones que nunca use Condition instancias de esta manera, excepto quizás dentro de su propia implementación.
Excepto cuando se indique, si se pasa un null valor para cualquier parámetro, se producirá una NullPointerException excepción .
<h2>Consideraciones de< implementación/h2>
Cuando se espera a un Condition, un "<Em>" se permite que se produzca,<> en general, como una concesión a la semántica de la plataforma subyacente. Esto tiene poco impacto práctico en la mayoría de los programas de aplicaciones, ya Condition que siempre debe esperarse en un bucle, probando el predicado de estado que se espera. Una implementación es libre para eliminar la posibilidad de reactivaciones falsas, pero se recomienda que los programadores de aplicaciones siempre asuman que pueden producirse y, por lo tanto, siempre esperen en un bucle.
Las tres formas de espera de condición (interrumpible, no interrumpible y cronomeada) pueden diferir en su facilidad de implementación en algunas plataformas y en sus características de rendimiento. En concreto, puede ser difícil proporcionar estas características y mantener una semántica específica, como las garantías de ordenación. Además, la capacidad de interrumpir la suspensión real del subproceso puede no ser siempre factible implementar en todas las plataformas.
Por lo tanto, no se requiere una implementación para definir exactamente las mismas garantías o semánticas para las tres formas de espera, ni es necesario admitir la interrupción de la suspensión real del subproceso.
Se requiere una implementación para documentar claramente la semántica y las garantías proporcionadas por cada uno de los métodos en espera, y cuando una implementación admite la interrupción de la suspensión del subproceso, debe obedecer la semántica de interrupción tal como se define en esta interfaz.
Como la interrupción generalmente implica la cancelación, y las comprobaciones de interrupción suelen ser poco frecuentes, una implementación puede favorecer la respuesta a una interrupción sobre el retorno normal del método. Esto es cierto incluso si se puede mostrar que la interrupción se produjo después de otra acción que puede haber desbloqueado el subproceso. Una implementación debe documentar este comportamiento.
Agregado en 1.5.
Documentación de Java para java.util.concurrent.locks.Condition.
Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.
Propiedades
| Nombre | Description |
|---|---|
| Handle |
Obtiene el valor JNI del objeto Android subyacente. (Heredado de IJavaObject) |
| JniIdentityHashCode |
Devuelve el valor de |
| JniManagedPeerState |
Estado del mismo nivel administrado. (Heredado de IJavaPeerable) |
| JniPeerMembers |
Compatibilidad con la invocación y el acceso de miembros. (Heredado de IJavaPeerable) |
| PeerReference |
Devuelve un JniObjectReference de la instancia de objeto Java ajustada. (Heredado de IJavaPeerable) |
Métodos
| Nombre | Description |
|---|---|
| Await() |
Hace que el subproceso actual espere hasta que se indique o se interrumpa Thread#interrupt. |
| Await(Int64, TimeUnit) |
Hace que el subproceso actual espere hasta que se señale o se interrumpa, o el tiempo de espera especificado transcurre. |
| AwaitNanos(Int64) |
Hace que el subproceso actual espere hasta que se señale o se interrumpa, o el tiempo de espera especificado transcurre. |
| AwaitUninterruptibly() |
Hace que el subproceso actual espere hasta que se señale. |
| AwaitUntil(Date) |
Hace que el subproceso actual espere hasta que se señale o se interrumpa, o bien la fecha límite especificada transcurre. |
| Disposed() |
Se llama cuando se ha eliminado la instancia. (Heredado de IJavaPeerable) |
| DisposeUnlessReferenced() |
Si no hay referencias pendientes a esta instancia, llama a |
| Finalized() |
Se llama cuando se ha finalizado la instancia. (Heredado de IJavaPeerable) |
| SetJniIdentityHashCode(Int32) |
Establezca el valor devuelto por |
| SetJniManagedPeerState(JniManagedPeerStates) |
|
| SetPeerReference(JniObjectReference) |
Establezca el valor devuelto por |
| Signal() |
Despierta un subproceso en espera. |
| SignalAll() |
Activa todos los subprocesos en espera. |
| UnregisterFromRuntime() |
Anule el registro de esta instancia para que el entorno de ejecución no lo devuelva de invocaciones futuras Java.Interop.JniRuntime+JniValueManager.PeekValue . (Heredado de IJavaPeerable) |
Métodos de extensión
| Nombre | Description |
|---|---|
| GetJniTypeName(IJavaPeerable) |
Obtiene el nombre JNI del tipo de la instancia |
| JavaAs<TResult>(IJavaPeerable) |
Intente coerción |
| JavaCast<TResult>(IJavaObject) |
Realiza una conversión de tipos comprobados en tiempo de ejecución de Android. |
| JavaCast<TResult>(IJavaObject) |
|
| TryJavaCast<TResult>(IJavaPeerable, TResult) |
Intente coerción |