CountDownLatch Clase

Definición

Espacio de nombres:: Java.Util.Concurrent

Ensamblado:: Mono.Android.dll

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í.

Ayuda de sincronización que permite que uno o varios subprocesos esperen hasta que se complete un conjunto de operaciones que se realizan en otros subprocesos.

[Android.Runtime.Register("java/util/concurrent/CountDownLatch", DoNotGenerateAcw=true)]
public class CountDownLatch : Java.Lang.Object

[<Android.Runtime.Register("java/util/concurrent/CountDownLatch", DoNotGenerateAcw=true)>]
type CountDownLatch = class
    inherit Object

Herencia: Object

JavaObject

Object
CountDownLatch

Atributos: RegisterAttribute

Comentarios

Ayuda de sincronización que permite que uno o varios subprocesos esperen hasta que se complete un conjunto de operaciones que se realizan en otros subprocesos.

Se CountDownLatch inicializa con un recuento em/em< determinado><>. Los #await await métodos bloquean hasta que el recuento actual alcanza cero debido a las invocaciones del #countDown método , después de lo cual se liberan todos los subprocesos en espera y las invocaciones posteriores de #await await devolución inmediatamente. Se trata de un fenómeno de un solo disparo: no se puede restablecer el recuento. Si necesita una versión que restablezca el recuento, considere la posibilidad de usar .CyclicBarrier

Un CountDownLatch es una herramienta de sincronización versátil y se puede usar para una serie de propósitos. Un CountDownLatch inicializado con un recuento de uno actúa como un bloqueo temporal simple de encendido y apagado, o puerta: todos los subprocesos que invocan #await await esperar a la puerta hasta que se abra mediante un subproceso invocando #countDown. Se puede usar una CountDownLatch inicialización <en em>N para hacer que un subproceso espere hasta <que em>N subprocesos hayan completado alguna acción o alguna acción se haya completado N veces.

Una propiedad útil de es CountDownLatch que no requiere que los subprocesos que llaman countDown esperen a que el recuento alcance cero antes de continuar, simplemente impide que cualquier subproceso pase más allá de un #await await hasta que se puedan pasar todos los subprocesos.

Uso de ejemplo: Este es un par de clases en las que un grupo de subprocesos de trabajo usan dos bloqueos temporales de cuenta atrás: <ul><li>La primera es una señal de inicio que impide que cualquier trabajador continúe hasta que el controlador esté listo para que continúen; <li>La segunda es una señal de finalización que permite al controlador esperar hasta que todos los trabajadores se hayan completado. </ul>

{@code
            class Driver { // ...
              void main() throws InterruptedException {
                CountDownLatch startSignal = new CountDownLatch(1);
                CountDownLatch doneSignal = new CountDownLatch(N);

                for (int i = 0; i < N; ++i) // create and start threads
                  new Thread(new Worker(startSignal, doneSignal)).start();

                doSomethingElse();            // don't let run yet
                startSignal.countDown();      // let all threads proceed
                doSomethingElse();
                doneSignal.await();           // wait for all to finish
              }
            }

            class Worker implements Runnable {
              private final CountDownLatch startSignal;
              private final CountDownLatch doneSignal;
              Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
                this.startSignal = startSignal;
                this.doneSignal = doneSignal;
              }
              public void run() {
                try {
                  startSignal.await();
                  doWork();
                  doneSignal.countDown();
                } catch (InterruptedException ex) {} // return;
              }

              void doWork() { ... }
            }}

Otro uso típico sería dividir un problema en N partes, describir cada parte con un runnable que ejecuta esa parte y cuenta hacia abajo en el bloqueo temporal y poner en cola todos los runnables en un ejecutor. Cuando se completen todas las subpartes, el subproceso de coordinación podrá pasar a través de await. (Cuando los subprocesos deben contar repetidamente hacia abajo de esta manera, en su lugar usar un CyclicBarrier. )

{@code
            class Driver2 { // ...
              void main() throws InterruptedException {
                CountDownLatch doneSignal = new CountDownLatch(N);
                Executor e = ...;

                for (int i = 0; i < N; ++i) // create and start threads
                  e.execute(new WorkerRunnable(doneSignal, i));

                doneSignal.await();           // wait for all to finish
              }
            }

            class WorkerRunnable implements Runnable {
              private final CountDownLatch doneSignal;
              private final int i;
              WorkerRunnable(CountDownLatch doneSignal, int i) {
                this.doneSignal = doneSignal;
                this.i = i;
              }
              public void run() {
                doWork();
                doneSignal.countDown();
              }

              void doWork() { ... }
            }}

Efectos de coherencia de memoria: hasta que el recuento alcanza cero, las acciones de un subproceso antes de llamar countDown()<a las acciones i>happen-before después de una devolución correcta de una correspondiente await() en otro subproceso.

Agregado en 1.5.

Java documentación para java.util.concurrent.CountDownLatch.

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.

Constructores

Nombre	Description
CountDownLatch(Int32)	Construye un `CountDownLatch` objeto inicializado con el recuento especificado.
CountDownLatch(IntPtr, JniHandleOwnership)	Constructor utilizado al crear representaciones administradas de objetos JNI; llamado por el tiempo de ejecución.

Propiedades

Nombre	Description
Class	Devuelve la clase en tiempo de ejecución de este `Object`objeto . (Heredado de Object)
Count	Devuelve el recuento actual.
Handle	Identificador de la instancia de Android subyacente. (Heredado de Object)
JniIdentityHashCode	Obtiene el código hash de identidad asignado a este Java del mismo nivel por el tiempo de ejecución de interoperabilidad. (Heredado de Object)
JniManagedPeerState	Ayuda de sincronización que permite que uno o varios subprocesos esperen hasta que se complete un conjunto de operaciones que se realizan en otros subprocesos. (Heredado de JavaObject)
JniPeerMembers	Ayuda de sincronización que permite que uno o varios subprocesos esperen hasta que se complete un conjunto de operaciones que se realizan en otros subprocesos.
PeerReference	Obtiene la referencia de objeto JNI para este Java del mismo nivel. (Heredado de Object)
ThresholdClass	Esta API admite la infraestructura mono para Android y no está pensada para usarse directamente desde el código.
ThresholdType	Esta API admite la infraestructura mono para Android y no está pensada para usarse directamente desde el código.

Métodos

Nombre	Description
Await()	Hace que el subproceso actual espere hasta que el bloqueo temporal se haya contado hasta cero, a menos que se interrumpa thread#interrupt.
Await(Int64, TimeUnit)	Hace que el subproceso actual espere hasta que el bloqueo temporal haya contado hasta cero, a menos que el subproceso sea Thread#interrupt interrumpida o el tiempo de espera especificado transcurre.
AwaitAsync()	Espera de forma asincrónica hasta que el número de bloqueos temporales alcanza cero.
AwaitAsync(Int64, TimeUnit)	Espera de forma asincrónica hasta que el número de bloqueos temporales alcanza cero o transcurre el tiempo de espera especificado.
Clone()	Crea y devuelve una copia de este objeto. (Heredado de Object)
Construct(JniObjectReference, JniObjectReferenceOptions)	Ayuda de sincronización que permite que uno o varios subprocesos esperen hasta que se complete un conjunto de operaciones que se realizan en otros subprocesos. (Heredado de JavaObject)
CountDown()	Disminuye el recuento del bloqueo temporal, liberando todos los subprocesos en espera si el recuento alcanza cero.
Dispose()	Libera los recursos mantenidos por este Java del mismo nivel. (Heredado de Object)
Dispose(Boolean)	Libera los recursos mantenidos por este Java del mismo nivel. (Heredado de Object)
DisposeUnlessReferenced()	Ayuda de sincronización que permite que uno o varios subprocesos esperen hasta que se complete un conjunto de operaciones que se realizan en otros subprocesos. (Heredado de JavaObject)
Equals(Object)	Ayuda de sincronización que permite que uno o varios subprocesos esperen hasta que se complete un conjunto de operaciones que se realizan en otros subprocesos. (Heredado de JavaObject)
Equals(Object)	Indica si algún otro objeto es "igual a" este. (Heredado de Object)
GetHashCode()	Devuelve un valor de código hash para el objeto . (Heredado de Object)
JavaFinalize()	Lo llama el recolector de elementos no utilizados en un objeto cuando la recolección de elementos no utilizados determina que no hay más referencias al objeto . (Heredado de Object)
Notify()	Activa un único subproceso que está esperando en el monitor de este objeto. (Heredado de Object)
NotifyAll()	Activa todos los subprocesos que están esperando en el monitor de este objeto. (Heredado de Object)
SetHandle(IntPtr, JniHandleOwnership)	Establece la propiedad Handle. (Heredado de Object)
SetPeerReference(JniObjectReference, JniObjectReferenceOptions)	Ayuda de sincronización que permite que uno o varios subprocesos esperen hasta que se complete un conjunto de operaciones que se realizan en otros subprocesos. (Heredado de JavaObject)
ToArray<T>()	Crea una matriz administrada a partir de este contenedor de matriz Java. (Heredado de Object)
ToString()	Devuelve una representación de cadena del objeto . (Heredado de Object)
UnregisterFromRuntime()	Anula el registro de este Java del mismo nivel del tiempo de ejecución de interoperabilidad. (Heredado de Object)
Wait()	Hace que el subproceso actual espere hasta que se despierte, normalmente por ser em notificado/em< o >em<interrumpido>/em<.><> (Heredado de Object)
Wait(Int64, Int32)	Hace que el subproceso actual espere hasta que se despierte, normalmente por ser <em>notificado</em> o <em>interrumpido</em>, o hasta que haya transcurrido una cierta cantidad de tiempo real. (Heredado de Object)
Wait(Int64)	Hace que el subproceso actual espere hasta que se despierte, normalmente por ser <em>notificado</em> o <em>interrumpido</em>, o hasta que haya transcurrido una cierta cantidad de tiempo real. (Heredado de Object)

Implementaciones de interfaz explícitas

Nombre	Description
IJavaPeerable.Disposed()	Ayuda de sincronización que permite que uno o varios subprocesos esperen hasta que se complete un conjunto de operaciones que se realizan en otros subprocesos. (Heredado de JavaObject)
IJavaPeerable.Finalized()	Ayuda de sincronización que permite que uno o varios subprocesos esperen hasta que se complete un conjunto de operaciones que se realizan en otros subprocesos. (Heredado de JavaObject)
IJavaPeerable.JniObjectReferenceControlBlock	Ayuda de sincronización que permite que uno o varios subprocesos esperen hasta que se complete un conjunto de operaciones que se realizan en otros subprocesos. (Heredado de JavaObject)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Ayuda de sincronización que permite que uno o varios subprocesos esperen hasta que se complete un conjunto de operaciones que se realizan en otros subprocesos. (Heredado de JavaObject)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Ayuda de sincronización que permite que uno o varios subprocesos esperen hasta que se complete un conjunto de operaciones que se realizan en otros subprocesos. (Heredado de JavaObject)
IJavaPeerable.SetPeerReference(JniObjectReference)	Ayuda de sincronización que permite que uno o varios subprocesos esperen hasta que se complete un conjunto de operaciones que se realizan en otros subprocesos. (Heredado de JavaObject)

Métodos de extensión

Nombre	Description
GetJniTypeName(IJavaPeerable)	Obtiene el nombre JNI del tipo de la instancia `self`.
JavaAs<TResult>(IJavaPeerable)	Intente coerción `self` para escribir `TResult`, comprobando que la coerción es válida en el lado de Java.
JavaCast<TResult>(IJavaObject)	Realiza una conversión de tipos comprobados en tiempo de ejecución de Android.
JavaCast<TResult>(IJavaObject)	Ayuda de sincronización que permite que uno o varios subprocesos esperen hasta que se complete un conjunto de operaciones que se realizan en otros subprocesos.
TryJavaCast<TResult>(IJavaPeerable, TResult)	Intente coerción `self` para escribir `TResult`, comprobando que la coerción es válida en el lado de Java.

Se aplica a