java 主线程判断子线程是不是都完成

java 主线程判断子线程是否都完成
场景：
    程序要通过多线程来处理相关业务，然后通过主线程判断子线程是否完成，然后再进行其它操作。

解决方案：利用java API (JDK1.5+)
CountDownLatch，一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

主要使用的方法：

public CountDownLatch(int count);

public void countDown();

public void await() throws InterruptedException


从API源码找到的示例：

<pre>
* 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() { ... }
* }
*
* </pre>
*
* <p>Another typical usage would be to divide a problem into N parts,
* describe each part with a Runnable that executes that portion and
* counts down on the latch, and queue all the Runnables to an
* Executor.  When all sub-parts are complete, the coordinating thread
* will be able to pass through await. (When threads must repeatedly
* count down in this way, instead use a {@link CyclicBarrier}.)
*
* <pre>
* 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() {
*      try {
*        doWork(i);
*        doneSignal.countDown();
*      } catch (InterruptedException ex) {} // return;
*   }
*
*   void doWork() { ... }
* }

即：

public class CountDownLatchDemo {
final static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    public static void main(String[] args) throws InterruptedException {
    CountDownLatch latch=new CountDownLatch(2);//两个工人的协作
    Worker worker1=new Worker("zhang san", 5000, latch);
    Worker worker2=new Worker("li si", 8000, latch);
    worker1.start();//
    worker2.start();//
    latch.await();//等待所有工人完成工作
        System.out.println("all work done at "+sdf.format(new Date()));
}
   
   
    static class Worker extends Thread{
    String workerName;
    int workTime;
    CountDownLatch latch;
    public Worker(String workerName ,int workTime ,CountDownLatch latch){
    this.workerName=workerName;
    this.workTime=workTime;
    this.latch=latch;
    }
    public void run(){
    System.out.println("Worker "+workerName+" do work begin at "+sdf.format(new Date()));
    doWork();//工作了
    System.out.println("Worker "+workerName+" do work complete at "+sdf.format(new Date()));
    latch.countDown();//工人完成工作，计数器减一

    }
   
    private void doWork(){
    try {
Thread.sleep(workTime);
} catch (InterruptedException e) {
e.printStackTrace();
}
    }
    }
   
    
}

在我的开发中的场景：

手工统计功能，在后台因为使用了多线程，所以当用户一点击完统一，前台就打印出统计成功，实际后台程序还不运行，不断地计算，因此要使用上面的方法来解决，等待线程工作完成时前台才输出统计完成。符合业务逻辑。