码迷，mamicode.com
首页 > 编程语言 > 详细

主线程等待所有子线程执行完成之后再继续往下执行的解决方案

时间：2015-01-06 17:49:39      阅读：199      评论：0      收藏：0      [点我收藏+]

标签：

问题背景：

目前需要解析十多个Excel文件并将数据导入到数据库，文件导出完成之后还有后续步骤需要处理，例如更新批次状态。
如果采用单线程的方式顺序去处理每个文件的话，感觉有点慢，虽说不算是特别慢，但是由于用户需要等待导入结果，
考虑到用于体验问题，因此需要坐下性能优化。既然是性能优化，基本都是考虑到使用多线程并发处理。但是多线线程有个问题，
就是启动多个线程后，如何让当前线程等待这些子线程执行完毕，因为需要根据所以子线程的执行结果来更新批次状态
 
解决方案1：
基本思路是这样：
每个SubThread子线程类实例有个自己的状态99-初始化  0-执行成功 1-执行失败，当执行完毕之后，将状态修改为0或者1
MainThread主线程类中有个List，用来登记所有子线程。子线程的创建通过主线程来创建，每次创建之后，都会将子线程添加到List中。
所有子线程创建完成之后，通过主线程的start方法启动所有子线程，并通过一个while循环来遍历List中的所有子线程的状态，
判断是否存在状态为99的，如果没有，则便是全部子线程执行完毕
/**
 * 子线程类
 * @author Administrator
 *
 */
public class SubThread implements Runnable{
    
    private int status = 99; //99-初始化  0-执行成功 1-执行失败 
 
    public void run() {
        System.out.println("开始执行...");
        try{
            Thread.sleep(2000);
        }catch(Exception e){
            e.printStackTrace();
        }
        status=0;
        System.out.println("执行完毕...");
    }
 
    public int getStatus() {
        return status;
    }
 
    public void setStatus(int status) {
        this.status = status;
    }
}  
/**
 * 主线程类
 * @author Administrator
 *
 */
public class MainThread {
    private List<SubThread> subThreadList = new ArrayList<SubThread>();
    
    /**
     * 创建子线程
     * @return
     */
    public SubThread createSubThread(){
        SubThread subThread = new SubThread();
        subThreadList.add(new SubThread());
        return subThread;
    }
    
    public boolean start(){
        for(SubThread subThread : subThreadList){
            new Thread(subThread).start();
        }
        
        /**
         * 监控所有子线程是否执行完毕
         */
        boolean continueFlag = true;
        while(continueFlag){
            for(SubThread subThread : subThreadList){
                if(subThread.getStatus()==99){
                    continueFlag = true;
                    break;
                }
                continueFlag = false;
            }
        }
        
        /**
         * 判断子线程的执行结果
         */
        boolean result = true;
        for(SubThread subThread : subThreadList){
            if(subThread.getStatus()!=0){
                result = false;
                break;
            }
        }
        
        return result;
    }
 
}  
测试代码：

    public static void main(String[] args) {
        MainThread main = new MainThread();
        main.createSubThread();
        main.createSubThread();
        main.createSubThread();
        boolean result = main.start();
        System.out.println(result);
    }
 
 
解决方案2：
通过计数器方式解决。基本思路如下：
计数器类CountLauncher负责记录正在执行的子线程的总数，所有的子线程共享该计数器类对象，当子线程执行完毕之后，调用计数器的counDown()方法进行计数器减1.
主线程通过计数器类来判断是否所有子线程都执行完毕。
/**
 * 计数器类
 * @author Administrator
 *
 */
public class CountLauncher {
    private int count;
    
    public CountLauncher(int count){
        this.count = count;
    }
    
    public synchronized void countDown(){
        count --;
    }
 
    public int getCount() {
        return count;
    }
 
    public void setCount(int count) {
        this.count = count;
    }
}  
 
/**
 * 子线程类
 * @author Administrator
 *
 */
public class SubThread implements Runnable{
    
    /**
     * 计数器类对象实例
     */
    private CountLauncher countLauncher;
    
    private int status = 99; //99-初始化  0-执行成功 1-执行失败 
    
 
    public void run() {
        System.out.println("开始执行...");
        try{
            Thread.sleep(2000);
        }catch(Exception e){
            e.printStackTrace();
        }
        status=0;
        System.out.println("执行完毕...");
        countLauncher.countDown();
    }
 
    public int getStatus() {
        return status;
    }
 
    public void setStatus(int status) {
        this.status = status;
    }
 
    public CountLauncher getCountLauncher() {
        return countLauncher;
    }
 
    public void setCountLauncher(CountLauncher countLauncher) {
        this.countLauncher = countLauncher;
    }
    
}  
 

 

 

/**
 * 主线程类
 * @author Administrator
 *
 */
public class MainThread {
    private List<SubThread> subThreadList = new ArrayList<SubThread>();
    
    /**
     * 创建子线程
     * @return
     */
    public synchronized SubThread createSubThread(){
        SubThread subThread = new SubThread();
        subThreadList.add(new SubThread());
        return subThread;
    }
    
    
    
    public boolean start(){
        CountLauncher countLauncher = new CountLauncher(subThreadList.size());
        for(SubThread subThread : subThreadList){
            subThread.setCountLauncher(countLauncher);
            new Thread(subThread).start();
        }
        
        while(countLauncher.getCount()>0){
            System.out.println(countLauncher.getCount());
        }
        
        /**
         * 判断子线程的执行结果
         */
        boolean result = true;
        for(SubThread subThread : subThreadList){
            if(subThread.getStatus()!=0){
                result = false;
                break;
            }
        }
        
        return result;
    }
    
    /**
     * 测试实例
     */
    public static void main(String[] args) {
        
        MainThread main = new MainThread();
        main.createSubThread();
        main.createSubThread();
        main.createSubThread();
        boolean result = main.start();
        System.out.println(result);
    }
 
}  
 
 
解决方案3（推荐）：
该方法的处理方式同解决方案2 ，只不过使用的是Java自带的计数器类java.util.concurrent.CountDownLatch。
还有一点就是不需要在主线程中通过while来监控所有子线程，是否通过调用它的await方法进行等待所有子线程的执行完毕。
使用计数器时，需要注意的一点是：子线程中调用countDown()方法时一定要放在最后来执行，否则会出现子线程未执行完毕，主线程就开始往下执行了。
因为一定计数器为0，就会自动唤醒主线程的。
/**
 * 子线程
 * @author Administrator
 *
 */
public class SubThread implements Runnable{
    
    private int status =99;
    private CountDownLatch threadsSignal;
 
    @Override
    public void run(){
        System.out.println("开始执行...");
        try{
            Thread.sleep(2000);
        }catch(Exception e){
            e.printStackTrace();
        }
        status=0;
        System.out.println("执行完毕...");
        threadsSignal.countDown();
    }
 
    public int getStatus() {
        return status;
    }
 
    public void setStatus(int status) {
        this.status = status;
    }
 
 
    public CountDownLatch getThreadsSignal() {
        return threadsSignal;
    }
 
    public void setThreadsSignal(CountDownLatch threadsSignal) {
        this.threadsSignal = threadsSignal;
    }
}  
 
public class MainThread {
    
    public List<SubThread> subThreadList = new ArrayList<SubThread>();
    
    /**
     * 创建子线程
     * @param clazzPath
     * @param methodName
     * @return
     */
    public SubThread createSubThread(){
        SubThread subThread = new SubThread();
        subThreadList.add(subThread);
        return subThread;
    }
    
    
    /**
     * 启动线程
     */
    public int start() throws Exception{
        
        CountDownLatch threadSignal = new CountDownLatch(subThreadList.size());
        for(SubThread subThread :subThreadList){
            subThread.setThreadsSignal(threadSignal);
            Thread thread = new Thread(subThread);
            thread.start();
        }
        threadSignal.await();
        System.out.println("所有子线程执行完毕...");
        for(SubThread subThread :subThreadList){
            if(subThread.getStatus()!=0){
                return 1;
            }
        }
        
        return 0;
    }
    
    public static void main(String[] args) throws Exception{
        MainThread main = new MainThread();
        main.createSubThread();
        main.createSubThread();
        main.createSubThread();
        main.createSubThread();
        int result = main.start();
        System.out.println("执行结果:" + result);
    }
    
 
}  

 

 

 
 

 





主线程等待所有子线程执行完成之后再继续往下执行的解决方案

标签：

原文地址：http://www.cnblogs.com/itmanxgl/p/a0fdc9caa310823318defda84fafba82.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！