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

原文地址：https://www.cnblogs.com/pony1223/p/9349239.html

时间： 2024-08-24 15:54:01

Java并发编程原理与实战六：主线程等待子线程解决方案的相关文章

Java并发编程原理与实战视频教程

14套java精品高级架构课,缓存架构,深入Jvm虚拟机,全文检索Elasticsearch,Dubbo分布式Restful 服务,并发原理编程,SpringBoot,SpringCloud,RocketMQ中间件,Mysql分布式集群,服务架构,运 维架构视频教程 14套精品课程介绍: 1.14套精 品是最新整理的课程,都是当下最火的技术,最火的课程,也是全网课程的精品: 2.14套资 源包含:全套完整高清视频.完整源码.配套文档: 3.知识也 是需要投资的,有投入才会有产出(保证投入产出比是

Java并发编程原理与实战

Java并发编程原理与实战网盘地址:https://pan.baidu.com/s/1c3mpC7A 密码: pe62备用地址(腾讯微云):https://share.weiyun.com/11ea938c7ad43783a934ed1d492eed8d 密码:ogHukS 原文地址:http://blog.51cto.com/13406637/2071116

JAVA进阶----主线程等待子线程各种方案比较（转）

创建线程以及管理线程池基本理解 参考原文链接:http://www.oschina.net/question/12_11255?sort=time 一.创建一个简单的java线程 在 Java 语言中,一个最简单的线程如下代码所示: Java代码   Runnable runnable = new Runnable(){ public void run(){ System.out.println("Run"); } } 可通过下面一行代码来启动这个线程: new Thread(runn

Java实现主线程等待子线程

本文介绍两种主线程等待子线程的实现方式,以5个子线程来说明: 1.使用Thread的join()方法,join()方法会阻塞主线程继续向下执行. 2.使用Java.util.concurrent中的CountDownLatch,是一个倒数计数器.初始化时先设置一个倒数计数初始值,每调用一次countDown()方法,倒数值减一,他的await()方法会阻塞当前进程,直到倒数至0. join方式代码如下: [java] view plain copy package com.test.thread

设置主线程等待子线程执行的方法

首先要注意的是: 1.java的Main线程结束之后,子线程还在运行.其实主线程已经退出了,但是JVM守护线程会等待所有的线程结束,才会退出.所以我们可以看到,子线程依然在继续执行. 2.那么如何实现主线程等待子线程的执行之后再结束,这个就要用到CountDownLatch,设置要执行的线程的个数,然后再子线程的run方法中调用countDown()的方法,递减线程的计数.在主线程结束之前,调用await()的方法,一直等待. 实现如下: public class Main extends Th

C#主线程等待子线程运行结束

佐左佑右 原文 C#主线程等待子线程运行结束 由于主程序中调用matlab的dll文件进行计算要用较长的时间,主界面会有很长时间的卡顿,造成的用户感受十分不好,因此我想在调用时,将调用放入子线程中,然后在主线程中弹出一个提示框,显示数据正在加载,等子线程运行结束后,主线程继续工作. 使用的是http://hi.baidu.com/oktell/item/5527f51d93abb4a5feded5a8中所提到的方法,用了这篇文章中的第一个方式,即不带参数的. 之后在其中加入了显示和关闭提示框的代

Java并发编程原理与实战八：产生线程安全性问题原因（javap字节码分析）

前面我们说到多线程带来的风险,其中一个很重要的就是安全性,因为其重要性因此,放到本章来进行讲解,那么线程安全性问题产生的原因,我们这节将从底层字节码来进行分析. 一.问题引出 先看一段代码 package com.roocon.thread.t3; public class Sequence { private int value; public int getNext(){ return value++; } public static void main(String[] args) { S

Java 并发编程中的 CountDownLatch 锁用于多个线程同时开始运行或主线程等待子线程结束

Java 5 开始引入的 Concurrent 并发软件包里面的 CountDownLatch 其实可以把它看作一个计数器,只不过这个计数器的操作是原子操作,同时只能有一个线程去操作这个计数器,也就是同时只能有一个线程去减这个计数器里面的值.CountDownLatch的一个非常典型的应用场景是:有一个任务想要往下执行,但必须要等到其他的任务执行完毕后才可以继续往下执行.假如我们这个想要继续往下执行的任务调用一个CountDownLatch对象的await()方法,其他的任务执行完自己的任务后调

Java多线程--让主线程等待子线程执行完毕

使用Java多线程编程时经常遇到主线程需要等待子线程执行完成以后才能继续执行,那么接下来介绍一种简单的方式使主线程等待. java.util.concurrent.CountDownLatch 使用countDownLatch.await()方法非常简单的完成主线程的等待: public class ThreadWait { public static void main(String[] args) throws InterruptedException { int threadNumber