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

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

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,就会自动唤醒主线程的。

 

------------------------------------------------------

------------------------------------------------------

我的个人域名

 

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

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

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

不讲虚的,只做实干家

Talk is cheap,show me the code

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页