CountDownLatch 类

定义

[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

继承

Object

Object

CountDownLatch

属性

RegisterAttribute

注解

一种同步帮助，允许一个或多个线程等待，直到在其他线程中执行一组操作完成。

使用给定<的 em>count</em> 初始化 ACountDownLatch。 方法 #await await 会阻止，直到当前计数由于方法的 #countDown 调用而达到零，之后所有等待线程都会释放，并立即发出任何后续的返回调用 #await await 。 这是一次性现象 -- 无法重置计数。 如果需要重置计数的版本，请考虑使用 .CyclicBarrier

A CountDownLatch 是一种通用的同步工具，可用于多种用途。 CountDownLatch一个初始化的计数为一个作为一个简单的开/关闩锁，或门：所有线程#await await调用入口等待，直到线程调用它#countDown打开。 CountDownLatch初始化为 <em>N</em> 可用于使一个线程等待，直到 <em>N</em> 线程完成某些操作，或某些操作已完成 N 次。

一个 CountDownLatch 有用的属性是，它不需要调用 countDown 等待计数达到零的线程在继续之前，它只是阻止任何线程继续超过一个 #await await 线程，直到所有线程都可以传递。

<b>示例用法：</b> 下面是一对类，其中一组工作线程使用两个倒计时闩锁： <ul><li>第一个是一个启动信号，阻止任何辅助角色继续，直到驱动程序准备好继续 <：li>第二个是一个完成信号，允许司机等待所有工人完成。 </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() { ... }
            }}

另一个典型用法是将问题划分为 N 个部分，使用可运行组件描述每个部件，该部分执行该部分并在闩锁上倒计时，并将所有 Runnables 排入执行程序。 完成所有子部分后，协调线程将能够通过 await。 （如果线程必须以这种方式重复倒计时，请改用 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() { ... }
            }}

内存一致性影响：在计数达到零之前，在调用 countDown()<i>发生前</i> 操作之前线程中的操作，然后再从另一个线程中从相应 await() 线程成功返回。

在 1.5 中添加。

Java文档java.util.concurrent.CountDownLatch。

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