Java并发编程-主线程等待子线程解决方案

小灰灰 2022-05-16 08:47 212阅读 0赞

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

public class TestThread extends Thread  
    {  
        public void run()  
        {  
            System.out.println(this.getName() + "子线程开始");  
            try  
            {  
                // 子线程休眠五秒  
                Thread.sleep(5000);  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  
            System.out.println(this.getName() + "子线程结束");  
        }  
    }

首先是一个线程，它执行完成需要5秒。

**1、主线程等待一个子线程**

public class Main  
    {  
        public static void main(String[] args)  
        {  
            long start = System.currentTimeMillis();  
              
            Thread thread = new TestThread();  
            thread.start();  
              
            long end = System.currentTimeMillis();  
            System.out.println("子线程执行时长：" + (end - start));  
        }  
    }

在主线程中，需要等待子线程执行完成。但是执行上面的main发现并不是想要的结果：

*子线程执行时长：0  
Thread-0子线程开始  
Thread-0子线程结束*

很明显主线程和子线程是并发执行的，主线程并没有等待。

对于只有一个子线程，如果主线程需要等待子线程执行完成，再继续向下执行，可以使用Thread的join()方法

> join()方法会阻塞主线程继续向下执行

public class Main  
    {  
        public static void main(String[] args)  
        {  
            long start = System.currentTimeMillis();  
              
            Thread thread = new TestThread();  
            thread.start();  
              
            try  
            {  
                thread.join();  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  
              
            long end = System.currentTimeMillis();  
            System.out.println("子线程执行时长：" + (end - start));  
        }  
    }

执行结果：

*Thread-0子线程开始  
Thread-0子线程结束  
子线程执行时长：5000*

> 注意：join()要在start()方法之后调用。

**2、主线程等待多个子线程**

比如主线程需要等待5个子线程

> 这5个线程之间是并发执行

public class Main  
    {  
        public static void main(String[] args)  
        {  
            long start = System.currentTimeMillis();  
              
            for(int i = 0; i < 5; i++)  
            {  
                Thread thread = new TestThread();  
                thread.start();  
                  
                try  
                {  
                    thread.join();  
                }  
                catch (InterruptedException e)  
                {  
                    e.printStackTrace();  
                }  
            }  
              
            long end = System.currentTimeMillis();  
            System.out.println("子线程执行时长：" + (end - start));  
        }  
    }

在上面的代码套上一个for循环，执行结果：

*Thread-0子线程开始  
Thread-0子线程结束  
Thread-1子线程开始  
Thread-1子线程结束  
Thread-2子线程开始  
Thread-2子线程结束  
Thread-3子线程开始  
Thread-3子线程结束  
Thread-4子线程开始  
Thread-4子线程结束  
子线程执行时长：25000*

由于thread.join()阻塞了主线程继续执行，导致for循环一次就需要等待一个子线程执行完成，而下一个子线程不能立即start()，5个子线程不能并发。

要想子线程之间能并发执行，那么需要在所有子线程start()后，在执行所有子线程的join()方法。

public class Main  
    {  
        public static void main(String[] args)  
        {  
            long start = System.currentTimeMillis();  
              
            List<Thread> list = new ArrayList<Thread>();  
            for(int i = 0; i < 5; i++)  
            {  
                Thread thread = new TestThread();  
                thread.start();  
                list.add(thread);  
            }  
              
            try  
            {  
                for(Thread thread : list)  
                {  
                    thread.join();  
                }  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  
              
            long end = System.currentTimeMillis();  
            System.out.println("子线程执行时长：" + (end - start));  
        }  
    }

执行结果：

*Thread-0子线程开始  
Thread-3子线程开始  
Thread-1子线程开始  
Thread-2子线程开始  
Thread-4子线程开始  
Thread-3子线程结束  
Thread-0子线程结束  
Thread-2子线程结束  
Thread-1子线程结束  
Thread-4子线程结束  
子线程执行时长：5000*

**3、主线程等待多个子线程（CountDownLatch实现）**

CountDownLatch是Java.util.concurrent中的一个同步辅助类，可以把它看做一个倒数计数器，就像神舟十号发射时倒数：10,9,8,7….2,1,0,走你。初始化时先设置一个倒数计数初始值，每调用一次countDown()方法，倒数值减一，await()方法会阻塞当前进程，直到倒数至0。

同样还是主线程等待5个并发的子线程。修改上面的代码，在主线程中，创建一个初始值为5的CountDownLatch，并传给每个子线程，在每个子线程最后调用countDown()方法对倒数器减1，当5个子线程等执行完成，那么CountDownLatch也就倒数完成，主线程调用await()方法等待5个子线程执行完成。

修改MyThread接收传入的CountDownLatch：

public class TestThread extends Thread    
    {    
        private CountDownLatch countDownLatch;    
                
        public TestThread(CountDownLatch countDownLatch)    
        {    
            this.countDownLatch = countDownLatch;    
        }    
      
        public void run()    
        {    
            System.out.println(this.getName() + "子线程开始");    
            try    
            {    
                // 子线程休眠五秒    
                Thread.sleep(5000);    
            }    
            catch (InterruptedException e)    
            {    
                e.printStackTrace();    
            }  
      
            System.out.println(this.getName() + "子线程结束");  
                
            // 倒数器减1  
            countDownLatch.countDown();  
        }  
    }

修改main：

public class Main  
    {  
        public static void main(String[] args)  
        {  
            long start = System.currentTimeMillis();  
              
            // 创建一个初始值为5的倒数计数器  
            CountDownLatch countDownLatch = new CountDownLatch(5);  
            for(int i = 0; i < 5; i++)  
            {  
                Thread thread = new TestThread(countDownLatch);  
                thread.start();  
            }  
              
            try  
            {  
                // 阻塞当前线程，直到倒数计数器倒数到0  
                countDownLatch.await();  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  
              
            long end = System.currentTimeMillis();  
            System.out.println("子线程执行时长：" + (end - start));  
        }  
    }

执行结果：

*Thread-0子线程开始  
Thread-2子线程开始  
Thread-1子线程开始  
Thread-3子线程开始  
Thread-4子线程开始  
Thread-2子线程结束  
Thread-4子线程结束  
Thread-1子线程结束  
Thread-0子线程结束  
Thread-3子线程结束  
子线程执行时长：5000*

注意：如果子线程中会有异常，那么countDownLatch.countDown()应该写在finally里面，这样才能保证异常后也能对计数器减1，不会让主线程永远等待。

另外，await()方法还有一个实用的重载方法：public booleanawait(long timeout, TimeUnit unit)，设置超时时间。

例如上面的代码，想要设置超时时间10秒，到了10秒无论是否倒数完成到0，都会不再阻塞主线程。返回值是boolean类型，如果是超时返回false，如果计数到达0没有超时返回true。

// 设置超时时间为10秒  
    boolean timeoutFlag = countDownLatch.await(10,TimeUnit.SECONDS);  
    if(timeoutFlag)  
    {  
        System.out.println("所有子线程执行完成");  
    }  
    else  
    {  
        System.out.println("超时");  
    }

**4、主线程等待线程池**

Java线程池java.util.concurrent.ExecutorService是很好用的多线程管理方式。ExecutorService的一个方法boolean awaitTermination(long timeout, TimeUnit unit)，即阻塞主线程，等待线程池的所有线程执行完成，用法和上面所说的CountDownLatch的public boolean await(long timeout,TimeUnit unit)类似，参数设置一个超时时间，返回值是boolean类型，如果超时返回false，如果线程池中的线程全部执行完成，返回true。

由于ExecutorService没有类似CountDownLatch的无参数的await()方法，只能通过awaitTermination来实现主线程等待线程池。

public class Main  
    {  
        public static void main(String[] args)  
        {  
            long start = System.currentTimeMillis();  
              
            // 创建一个同时允许两个线程并发执行的线程池  
            ExecutorService executor = Executors.newFixedThreadPool(2);  
            for(int i = 0; i < 5; i++)  
            {  
                Thread thread = new TestThread();  
                executor.execute(thread);  
            }  
            executor.shutdown();  
              
            try  
            {  
                // awaitTermination返回false即超时会继续循环，返回true即线程池中的线程执行完成主线程跳出循环往下执行，每隔10秒循环一次  
                while (!executor.awaitTermination(10, TimeUnit.SECONDS));  
            }  
            catch (InterruptedException e)  
            {  
                e.printStackTrace();  
            }  
              
            long end = System.currentTimeMillis();  
            System.out.println("子线程执行时长：" + (end - start));  
        }  
    }

执行结果：

*Thread-0子线程开始  
Thread-1子线程开始  
Thread-0子线程结束  
Thread-2子线程开始  
Thread-1子线程结束  
Thread-3子线程开始  
Thread-2子线程结束  
Thread-4子线程开始  
Thread-3子线程结束  
Thread-4子线程结束  
子线程执行时长：15000*

另外，while(!executor.isTerminated())也可以替代上面的while (!executor.awaitTermination(10,TimeUnit.SECONDS))，isTerminated()是用来判断线程池是否执行完成。但是二者比较我认为还是awaitTermination更好，它有一个超时时间可以控制每隔多久循环一次，而不是一直在循环来消耗性能。

**5.其它方案参考：**

**解决方案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);
        }
     
    }

**六.总结**

**解决方案（推荐）：**

使用的是Java自带的计数器类java.util.concurrent.CountDownLatch。

还有一点就是不需要在主线程中通过while来监控所有子线程，是否通过调用它的await方法进行等待所有子线程的执行完毕。

使用计数器时，需要注意的一点是：子线程中调用countDown()方法时一定要放在最后来执行，否则会出现子线程未执行完毕，主线程就开始往下执行了。因为一定计数器为0，就会自动唤醒主线程的。

\------------------------------------------------------

我的[个人域名][Link 1]

期望和大家一起学习，共同进步，共勉，O(∩\_∩)O谢谢

欢迎交流问题，可加个人QQ 469580884

或者，加我的群号 **751925591**，一起探讨交流问题

不讲虚的，只做实干家

Talk is cheap，show me the code