Java｜CountDownLatch

 1public class CountDownLatchUtil {
 2    private CountDownLatch start;
 3    private CountDownLatch end;
 4    private int poolSize;
 5
 6    public CountDownLatchUtil() {
 7        this(10);
 8    }
 9
10    public CountDownLatchUtil(int poolSize) {
11        this.poolSize = poolSize;
12        start = new CountDownLatch(1);
13        end = new CountDownLatch(poolSize);
14    }
15
16    public void latch(MyFunctionalInterface functionalInterface) throws InterruptedException {
17        ExecutorService service = Executors.newFixedThreadPool(poolSize);
18        for (int i = 0; i < poolSize; i++) {
19            Runnable runnable = new Runnable() {
20
21                @Override
22                public void run() {
23                    try {
24                        start.await();
25                        functionalInterface.run();
26                    } catch (InterruptedException e) {
27                        e.printStackTrace();
28                    } finally {
29                        end.countDown();
30                    }
31                }
32            };
33            service.execute(runnable);
34        }
35        // start all task
36        start.countDown();
37        // wait until all task finish
38        end.await();
39    }
40
41    @FunctionalInterface
42    public interface MyFunctionalInterface {
43        void run();
44    }
45}

 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  }

 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  }