java并发编程_CountDownLanch(倒计数锁存器)应用场景

使用介绍:

一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待。

用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法,所以在当前计数到达零之前,await 方法会一直受阻塞。之后,会释放所有等待的线程,await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数,请考虑使用 CyclicBarrier

CountDownLatch 是一个通用同步工具,它有很多用途。将计数 1 初始化的 CountDownLatch 用作一个简单的开/关锁存器,或入口:在通过调用 countDown() 的线程打开入口前,所有调用 await 的线程都一直在入口处等待。用 N 初始化的 CountDownLatch 可以使一个线程在 N 个线程完成某项操作之前一直等待,或者使其在某项操作完成 N 次之前一直等待。

CountDownLatch 的一个有用特性是,它不要求调用 countDown 方法的线程等到计数到达零时才继续,而在所有线程都能通过之前,它只是阻止任何线程继续通过一个 await

 

举个例子:例如我们一群人(多个线程)要从北京一起到广州旅行,我们约定所有人都到达北京西站集合,当最后一个人到达北京西站的那一刻(计数器为0),我们才会一起同时进行下面的操作。

 

countdownLanch场景1:

示例用法: 下面给出了两个类,其中一组 worker 线程使用了两个倒计数锁存器

  • 第一个类是一个启动信号,在 driver 为继续执行 worker 做好准备之前,它会阻止所有的 worker 继续执行。
  • 第二个类是一个完成信号,它允许 driver 在完成所有 worker 之前一直等待。
 1 class Driver { // ...
 2    void main() throws InterruptedException {
 3      CountDownLatch startSignal = new CountDownLatch(1);
 4      CountDownLatch doneSignal = new CountDownLatch(N);
 5 
 6      for (int i = 0; i < N; ++i) // create and start threads
 7        new Thread(new Worker(startSignal, doneSignal)).start();
 8 
 9      doSomethingElse();            // don't let run yet
10      startSignal.countDown();      // let all threads proceed
11      doSomethingElse();
12      doneSignal.await();           // wait for all to finish
13    }
14  }
15 
16  class Worker implements Runnable {
17    private final CountDownLatch startSignal;
18    private final CountDownLatch doneSignal;
19    Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
20       this.startSignal = startSignal;
21       this.doneSignal = doneSignal;
22    }
23    public void run() {
24       try {
25         startSignal.await();
26         doWork();
27         doneSignal.countDown();
28 } catch (InterruptedException ex) {} // return;
29    }
30 
31    void doWork() { ... }
32  }

countdownLanch场景2:

另一种典型用法是,将一个问题分成 N 个部分,用执行每个部分并让锁存器倒计数的 Runnable 来描述每个部分,然后将所有 Runnable 加入到 Executor 队列。当所有的子部分完成后,协调线程就能够通过 await。(当线程必须用这种方法反复倒计数时,可改为使用 CyclicBarrier。)

 

 1  class Driver2 { // ...
 2    void main() throws InterruptedException {
 3      CountDownLatch doneSignal = new CountDownLatch(N);
 4      Executor e = ...
 5 
 6      for (int i = 0; i < N; ++i) // create and start threads
 7        e.execute(new WorkerRunnable(doneSignal, i));
 8 
 9      doneSignal.await();           // wait for all to finish
10    }
11  }
12 
13  class WorkerRunnable implements Runnable {
14    private final CountDownLatch doneSignal;
15    private final int i;
16    WorkerRunnable(CountDownLatch doneSignal, int i) {
17       this.doneSignal = doneSignal;
18       this.i = i;
19    }
20    public void run() {
21       try {
22         doWork(i);
23         doneSignal.countDown();
24       } catch (InterruptedException ex) {} // return;
25    }
26 
27    void doWork() { ... }
28  }

内存一致性效果:线程中调用 countDown() 之前的操作 happen-before 紧跟在从另一个线程中对应 await() 成功返回的操作。

    原文作者:java锁
    原文地址: http://www.cnblogs.com/zhangshiwen/p/5708886.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞