多线程---java判断多线程结束

需求应用场景

我们多线程抓取数据或者多线程执行任务时，有时候需要多线程执行完后      才能执行其他的任务。

这种情况下  我们就需要判断多线程什么时候执行完。有以下几种方法(推荐方法二)

方法一 isTerminated

使用isTerminated来判断所有任务都已完成，会返回true。但是前提是启用shutdown顺序关闭。

shutdown

void shutdown()
启动一次顺序关闭，执行以前提交的任务，但不接受新任务。如果已经关闭，则调用没有其他作用。
抛出：
SecurityException - 如果安全管理器存在并且关闭，此 ExecutorService 可能操作某些不允许调用者修改的线程（因为它没有保持RuntimePermission("modifyThread")），或者安全管理器的 checkAccess 方法拒绝访问。

isTerminated

boolean isTerminated()
如果关闭后所有任务都已完成，则返回 true。注意，除非首先调用 shutdown 或 shutdownNow，否则 isTerminated 永不为 true。
返回：
如果关闭后所有任务都已完成，则返回 true

使用例子

先调用shundown再调用isTerminated判断

/**
 * 采用线程池开启多个子线程，主线程等待所有的子线程执行完毕  
 */  
public static void moreThread() {  
    try {  
        int threadNum = 0;  
        for (int i = 0; i < 10; i++) {  
            threadNum++;  
              
            final int currentThreadNum = threadNum;  
            exe.execute(new Runnable() {  
                  
                @Override  
                public void run() {  
                    try {  
                        System.out.println("子线程[" + currentThreadNum + "]开启");  
                        Thread.sleep(1000*10);  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }finally{  
                        System.out.println("子线程[" + currentThreadNum + "]结束");  
                    }  
                }  
            });    
        }  
          
        System.out.println("已经开启所有的子线程");  
        exe.shutdown();  
        System.out.println("shutdown()：启动一次顺序关闭，执行以前提交的任务，但不接受新任务。");  
        while(true){  
            if(exe.isTerminated()){  
                System.out.println("所有的子线程都结束了！");  
                break;  
            }  
            Thread.sleep(1000);    
        }  
          
    } catch (InterruptedException e) {  
        e.printStackTrace();  
    }finally{  
        System.out.println("主线程结束");  
    }  
}  

输出结果

子线程[1]开启  
子线程[6]开启  
子线程[2]开启  
子线程[5]开启  
子线程[9]开启  
已经开启所有的子线程  
子线程[3]开启  
子线程[7]开启  
子线程[10]开启  
shutdown()：启动一次顺序关闭，执行以前提交的任务，但不接受新任务。  
子线程[4]开启  
子线程[8]开启  
子线程[6]结束  
子线程[3]结束  
子线程[7]结束  
子线程[2]结束  
子线程[1]结束  
子线程[5]结束  
子线程[9]结束  
子线程[4]结束  
子线程[10]结束  
子线程[8]结束  
所有的子线程都结束了！  
主线程结束

方法二CountDownLatch

CountDownLatch是一个同步辅助类,用来判断多线程是否执行完成。

它的原理是首先声明一共运行多少个线程任务，然后每完成一个线程任务，计数器就减一，当计数器等于0，说明所有的多线程都运行完成了。

主要方法

 public CountDownLatch(int count);
 public void countDown();
 public void await() throws InterruptedException
 
构造方法参数指定了计数的次数
countDown方法，当前线程调用此方法，则计数减一
await方法，调用此方法会一直阻塞当前线程，直到计时器的值为0。

使用方法

如果你确定了你开启的线程数。 
那么在主程序运行前。 
CountDownLatch countdown = new CountDownLatch(10);//这里的10就是你的子线程数。 

在每个子线程结束后，调用 countdown.countDown(); 

在主线程里启动子线程的方法后面添加。 
countdown.await();//这里进行同步等待 

等所有子线程结束后，执行 countdown.await()后面的代码。

使用例子

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();  
            }  
        }  
    }  
      
       
}  

 

输出结果

Worker zhang san do work begin at 2011-04-14 11:05:11
Worker li si do work begin at 2011-04-14 11:05:11
Worker zhang san do work complete at 2011-04-14 11:05:16
Worker li si do work complete at 2011-04-14 11:05:19
all work done at 2011-04-14 11:05:19

方法三CyclicBarrier

CyclicBarrier ，一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。CyclicBarrier 支持一个可选的 Runnable 命令，在一组线程中的最后一个线程到达之后（但在释放所有线程之前），该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新共享状态，此屏障操作 很有用。 

主要方法

//设置parties、count及barrierCommand属性。
CyclicBarrier(int):

//当await的数量到达了设定的数量后，首先执行该Runnable对象。
CyclicBarrier(int,Runnable):

//通知barrier已完成线程
await():

使用例子

我们需要统计全国的业务数据。其中各省的数据库是独立的，也就是说按省分库。并且统计的数据量很大，统计过程也比较慢。为了提高性能，快速计算。我们采取并发的方式，多个线程同时计算各省数据，最后再汇总统计。在这里CyclicBarrier就非常有用。看代码： 
主要类：
/**  
 * 各省数据独立，分库存偖。为了提高计算性能，统计时采用每个省开一个线程先计算单省结果，最后汇总。  
 *   
 * @author guangbo email:weigbo@163.com  
 *   
 */  
public class Total {     
    // private ConcurrentHashMap result = new ConcurrentHashMap();   
  
    public static void main(String[] args) {   
        TotalService totalService = new TotalServiceImpl();   
        CyclicBarrier barrier = new CyclicBarrier(5,   
                new TotalTask(totalService));   
  
        // 实际系统是查出所有省编码code的列表，然后循环，每个code生成一个线程。   
        new BillTask(new BillServiceImpl(), barrier, "北京").start();   
        new BillTask(new BillServiceImpl(), barrier, "上海").start();   
        new BillTask(new BillServiceImpl(), barrier, "广西").start();   
        new BillTask(new BillServiceImpl(), barrier, "四川").start();   
        new BillTask(new BillServiceImpl(), barrier, "黑龙江").start();   
  
    }   
}   
  
/**  
 * 主任务：汇总任务  
 */  
class TotalTask implements Runnable {   
    private TotalService totalService;   
  
    TotalTask(TotalService totalService) {   
        this.totalService = totalService;   
    }   
  
    public void run() {   
        // 读取内存中各省的数据汇总，过程略。   
        totalService.count();   
        System.out.println("=======================================");   
        System.out.println("开始全国汇总");   
    }   
}   
  
/**  
 * 子任务：计费任务  
 */  
class BillTask extends Thread {   
    // 计费服务   
    private BillService billService;   
    private CyclicBarrier barrier;   
    // 代码，按省代码分类，各省数据库独立。   
    private String code;   
  
    BillTask(BillService billService, CyclicBarrier barrier, String code) {   
        this.billService = billService;   
        this.barrier = barrier;   
        this.code = code;   
    }   
  
    public void run() {   
        System.out.println("开始计算--" + code + "省--数据！");   
        billService.bill(code);   
        // 把bill方法结果存入内存，如ConcurrentHashMap,vector等,代码略   
        System.out.println(code + "省已经计算完成,并通知汇总Service！");   
        try {   
            // 通知barrier已经完成   
            barrier.await();   
        } catch (InterruptedException e) {   
            e.printStackTrace();   
        } catch (BrokenBarrierException e) {   
            e.printStackTrace();   
        }   
    }   
  
} 

 

输出结果

开始计算--北京省--数据！ 
开始计算--上海省--数据！ 
北京省已经计算完成,并通知汇总Service！ 
开始计算--四川省--数据！ 
四川省已经计算完成,并通知汇总Service！ 
上海省已经计算完成,并通知汇总Service！ 
开始计算--广西省--数据！ 
广西省已经计算完成,并通知汇总Service！ 
开始计算--黑龙江省--数据！ 
黑龙江省已经计算完成,并通知汇总Service！