Java主线程等待子线程、线程池

最新推荐文章于 2023-05-16 12:03:48 发布
最新推荐文章于 2023-05-16 12:03:48 发布
阅读量420 收藏 2
点赞数
分类专栏： java技术 文章标签： 线程池 java
原文链接：https://blog.csdn.net/xiao__gui/article/details/9213413
版权

 

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更好，它有一个超时时间可以控制每隔多久循环一次，而不是一直在循环来消耗性能。

丶自定义
关注
专栏目录
java主线程等待线程池结束_Java主线程等待子线程、线程池
weixin_36214783的博客
02-25 1434
public class TestThread extends Thread{public void run(){System.out.println(this.getName() + "子线程开始");try{// 子线程休眠五秒Thread.sleep(5000);}catch (InterruptedException e){e.printStackTrace();}System.out.p...
在Java线程池中 主线程等待子线程完成任务 并返回
telltao的博客
07-08 1915
Java创建一个固定长度的线程池执行业务逻辑完成 创建一个固定长度的线程池 /** * <pre> * Create By Liu Tao * 创建一个线程池，该线程池重用在共享无界队列上运行的固定数量的线程。 * 在任何时候，大多数Threads线程都是活动的处理任务。 * 如果在所有线程都处于活动状态时提交其他任务，它们将在...
Java简单实现“主线程等待所有子线程完成再继续”
03-25
NULL 博文链接：https://zhaoningbo.iteye.com/blog/1158225
主线程等待线程池所有任务完成
十万小时之旅
09-22 473
原文出处：http://blog.chenlb.com/2008/12/main-thread-wait-all-sub-thread-finish-task-in-thread-pool.html 用线程池编写多线程程序时，当所有任务完成时，要做一些统计的工作。而统计工作必须要在所有任务完成才能做。所以要让主线程等待所有任务完成。可以使用ThreadPoolExecutor.await...
Java实现主线程等待子线程
p312011150的博客
09-09 198
Java实现主线程等待子线程 标签： 线程thread 2014-06-11 22:10 20489人阅读 评论(1) 收藏 举报  分类： Java（14）  版权声明：本文为博主原创文章，未经博主允许不得转载。 本文介绍两种主线程等待子线程的实现方式，以5个子线程来说明： 1、使用Thread的join()方法，join()方法
JAVA主线程等待子线程执行完毕再执行[参照].pdf
10-11
JAVA 主线程等待子线程执行完毕再执行 JAVA 中的线程控制是非常重要的一部分，而在实际开发中，我们经常会遇到需要主线程等待子线程执行完毕再执行的情况。这种情况下，我们可以使用两种方式来实现：主动式和被动式...
c++主线程等待子线程结束_主线程等待子线程结束的多种方法
weixin_39629129的博客
12-21 2905
程的运行时间”。while循环对于“主线程如何获取子线程总运行时间”的问题，最开始想到的是使用while循环进行轮询：Thread t = new Thread(() -> {//子线程进行字符串连接操作int num = 1000;String s = "";for (int i = 0; i < num; i++) {s += "Java";}System.out.println(...
java 主线程等待子线程结束
xuejianxinokok的专栏
09-12 2478
第一种方式join/** * Date:2016年9月7日下午7:43:13 * Copyright (c) 2016, www.bwbroad.com All Rights Reserved. * */ package test.join; import test.Task; /** * Description: TODO * Date: 2016年9月7日 下午7:4
java 主线程等待_Java实现主线程等待子线程
weixin_42138703的博客
02-12 312
本文介绍两种主线程等待子线程的实现方式，以5个子线程来说明：1、使用Thread的join()方法，join()方法会阻塞主线程继续向下执行。2、使用Java.util.concurrent中的CountDownLatch，是一个倒数计数器。初始化时先设置一个倒数计数初始值，每调用一次countDown()方法，倒数值减一，他的await()方法会阻塞当前进程，直到倒数至0。join方式代码如下：...
主线程等待线程池结束
iteye_4755的博客
08-06 278
http://dongdong1314.blog.51cto.com/389953/224932/ 所有SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝...
java 主线程等待_Java：主线程和子线程—–主线程等待子线程结束 | 学步园
weixin_29722783的博客
02-20 280
想做的一个程序如题，主要是想统计子线程都执行完毕所用的时间，网上搜索到了CountDownLatch这个类，这个工具类可以理解为计数器。在这里用于表示正在运行的线程数，当一个子线程结束的时候，将这个计数器减一，最后在主线程的一个地方等待子线程全部执行完毕，再继续运行等待后面的程序。写了个Demo程序，如下：//子线程public class SubThread extends Thread{//子...
Java多线程--让主线程等待子线程执行完毕
weixin_41017246的博客
10-10 272
参考链接：https://www.cnblogs.com/eoss/p/5902939.html 使用Java多线程编程时经常遇到主线程需要等待子线程执行完成以后才能继续执行，那么接下来介绍一种简单的方式使主线程等待。 java.util.concurrent.CountDownLatch 使用countDownLatch.await()方法非常简单的完成主线程的等待： public...
Java主线程等待子线程执行完毕-CountDownLatch
过往记忆大数据
12-11 6460
主线程：   //Main主线程 publicclassMainThread { publicstaticvoid main(String[] args) throwsInterruptedException { longstartTime = System.currentTimeMillis(); intthreadNum =
java线程池主线程等待子线程执行完成
最新发布
2301_78145669的博客
05-16 1564
系列方法可以帮助我们等待一个子线程的结束。处理完后再把那段逻辑的处理结果进行汇。被动式指主线程被动的等待子线程的结。有没有另外一种方法可以等待子线程结束。那么主线程如何等待子线程工作完成呢。他的作用是判断线程是否已经执行结束。这 里是得益于我们用了一个阻塞队列。是异步的去执行需要执行的内容的。以上几种情况都是针对子线程只有。拿到什么我们是不必去关心的。包里面提供了好多有用的东东。我们只需要在子线程执行之前。可以等待所有子线程执行结。今天讨论一个入门级的话题。本程序的数据有可能是如下。
Java主线程处理子线程异常与事务回滚策略
2. **同步与阻塞** - 实现问题解决的场景是通过同步机制，如主线程启动一个Callable或FutureTask，这样主线程可以等待子线程的结果，并在子线程完成时获取其状态。Callable接口允许抛出异常，而FutureTask提供了获取...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值