CountDownLatch Klasse

Definition

[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

Vererbung

Object

JavaObject

Object

CountDownLatch

Attribute

RegisterAttribute

Hinweise

Eine Synchronisierungshilfe, mit der mindestens ein Threads warten kann, bis eine Reihe von Vorgängen in anderen Threads abgeschlossen wird.

A CountDownLatch wird mit einer bestimmten <Em-Anzahl>/Em<> initialisiert. Die #await await Methoden blockieren, bis die aktuelle Anzahl aufgrund von Aufrufen der #countDown Methode null erreicht, nach denen alle wartenden Threads freigegeben werden und alle nachfolgenden Aufrufe der #await await Rückgabe sofort. Dies ist ein Einschussphänomen – die Anzahl kann nicht zurückgesetzt werden. Wenn Sie eine Version benötigen, die die Anzahl zurücksetzt, sollten Sie eine CyclicBarrier.

A CountDownLatch ist ein vielseitiges Synchronisierungstool und kann für eine Reihe von Zwecken verwendet werden. Eine CountDownLatch initialisierte Anzahl von einer dient als einfache Ein-/Aus-Riegelung oder Tor: Alle Threads #await await , die aufgerufen werden, warten am Tor, bis sie von einem Thread geöffnet wird, der aufgerufen #countDownwird. Eine CountDownLatch initialisierte<> N</em-Datei> kann verwendet werden, um einen Thread zu warten, bis <em>N</em-Threads> eine Aktion abgeschlossen haben oder eine Aktion N-Mal abgeschlossen wurde.

Eine nützliche Eigenschaft eines Objekts CountDownLatch besteht darin, dass Threads, die aufrufen countDown , nicht warten, bis die Anzahl null erreicht, bevor sie fortfahren, sie verhindert einfach, dass ein Thread über eine #await await weitergeht, bis alle Threads übergeben werden konnten.

<b>Beispielverwendung:</b> Hier ist ein Paar Klassen, in denen eine Gruppe von Arbeitsthreads zwei Countdown-Gitter verwendet: <ul><li>Der erste ist ein Startsignal, das verhindert, dass jeder Mitarbeiter fortfahren kann, bis der Fahrer bereit ist, fortzufahren; <li>Die zweite ist ein Abschlusssignal, das es dem Fahrer ermöglicht, zu warten, bis alle Mitarbeiter abgeschlossen sind. </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() { ... }
            }}

Eine weitere typische Verwendung wäre das Aufteilen eines Problems in N-Teile, beschreiben jeden Teil mit einem Runnable-Element, das diesen Teil ausführt und auf den Verschluss zählt, und alle Runnables an einen Executor in die Warteschlange stellen. Wenn alle Teilteile fertig sind, kann der koordinierende Thread warten. (Wenn Threads auf diese Weise wiederholt nach unten zählen müssen, verwenden Sie stattdessen eine 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() { ... }
            }}

Speicherkonsistenzeffekte: Bis die Anzahl null erreicht, werden Aktionen in einem Thread vor dem Aufrufen countDown()<von "i>happen-before</i> "-Aktionen nach einer erfolgreichen Rückgabe von einem entsprechenden await() in einem anderen Thread zurückgegeben.

Hinzugefügt in 1.5.

Java-Dokumentation für java.util.concurrent.CountDownLatch.

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die vom Android Open Source-Projekt erstellt und freigegeben werden und gemäß den in der Creative Commons 2.5 Attribution License beschriebenen Begriffen verwendet werden.