「java子线程执行完毕」main线程会等待子线程执行结束吗
今天给各位分享java子线程执行完毕的知识，其中也会对main线程会等待子线程执行结束吗进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
- 1、Java如何判断线程池中所有任务执行完毕
- 2、Java如何等待子线程执行结束
- 3、java 如何实现等待子线程结束
- 4、如何实现java主线程等待子线程执行完毕之后再执行
- 5、java主线程结束和子线程结束
Java如何判断线程池中所有任务执行完毕
Java 如何判断线程池所有任务是否执行完
shutdown
void shutdown()
启动一次顺序关闭，执行以前提交的任务，但不接受新任务。如果已经关闭，则调用没有其他作用。
抛出：
SecurityException - 如果安全管理器存在并且关闭，此 ExecutorService 可能操作某些不允许调用者修改的线程（因为它没有保持RuntimePermission("modifyThread")），或者安全管理器的 checkAccess 方法拒绝访问。
isTerminated
boolean isTerminated()
如果关闭后所有任务都已完成，则返回 true。注意，除非首先调用 shutdown 或 shutdownNow，否则 isTerminated 永不为 true。
返回：
如果关闭后所有任务都已完成，则返回 true
/**
[java] view plain copy
* 采用线程池开启多个子线程，主线程等待所有的子线程执行完毕
*/
public static void moreThread() {
try {
int threadNum = 0;
for (int i = 0; i 10; i++) {
threadNum++;
final int currentThreadNum = threadNum;
exe.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println("子线程[" + currentThreadNum + "]开启");
Thread.sleep(1000*10);
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
System.out.println("子线程[" + currentThreadNum + "]结束");
}
}
});
}
System.out.println("已经开启所有的子线程");
exe.shutdown();
System.out.println("shutdown()：启动一次顺序关闭，执行以前提交的任务，但不接受新任务。");
while(true){
if(exe.isTerminated()){
System.out.println("所有的子线程都结束了！");
break;
}
Thread.sleep(1000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
System.out.println("主线程结束");
}
}
[java] view plain copy
子线程[1]开启
子线程[6]开启
子线程[2]开启
子线程[5]开启
子线程[9]开启
已经开启所有的子线程
子线程[3]开启
子线程[7]开启
子线程[10]开启
shutdown()：启动一次顺序关闭，执行以前提交的任务，但不接受新任务。
子线程[4]开启
子线程[8]开启
子线程[6]结束
子线程[3]结束
子线程[7]结束
子线程[2]结束
子线程[1]结束
子线程[5]结束
子线程[9]结束
子线程[4]结束
子线程[10]结束
子线程[8]结束
所有的子线程都结束了！
主线程结束
Java如何等待子线程执行结束
先调用
shutdown
在调用
isTerminated
例：
/*
* 采用线程池开启多个子线程，主线程等待所有的子线程执行完毕
*/
public static void moreThread() {
try {
int threadNum = 0;
for (int i = 0; i 10; i++) {
threadNum++;
final int currentThreadNum = threadNum;
exe.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println("子线程[" + currentThreadNum + "]开启");
Thread.sleep(1000*10);
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
System.out.println("子线程[" + currentThreadNum + "]结束");
}
}
});
}
System.out.println("已经开启所有的子线程");
exe.shutdown();
System.out.println("shutdown()：启动一次顺序关闭，执行以前提交的任务，但不接受新任务。");
while(true){
if(exe.isTerminated()){
System.out.println("所有的子线程都结束了！");
break;
}
Thread.sleep(1000);
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
System.out.println("主线程结束");
}
}
java 如何实现等待子线程结束
有多种实现方式，下面列出两种。
第一种：实现Callable类，使用有返回值的线程，只有线程执行完成后才会返回结果。
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.*;
public class Main {
// 初始化一个容量为10的线程池
static final ExecutorService pool = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws ExecutionException, InterruptedException {
ListFutureString futures = new ArrayList();
for (int i = 0; i 3; i++) {
MyThread thread = new MyThread("线程" + i);
futures.add(pool.submit(thread));
}
for (FutureString future : futures) {
String name = future.get();
System.out.println(name + "执行完成...");
}
System.out.println("所有线程执行完成!");
}
}
class MyThread implements CallableString {
private String name;
public MyThread(String name) {
this.name = name;
}
@Override
public String call() throws Exception {
// TODO 执行业务
// 随机延迟，模拟线程耗时
Thread.sleep(1000 + new Random().nextInt(2000));
return name;
}
}
第二种：使用CountDownLatch实现线程计数，代码如下：
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Main2 {
// 初始化一个容量为10的线程池
static final ExecutorService pool = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws InterruptedException {
int threadCount = 3;
// 初始化CountDownLatch，用于线程计数
CountDownLatch latch = new CountDownLatch(threadCount);
for (int i = 0; i threadCount; i++) {
MyThread thread = new MyThread("线程" + i, latch);
pool.execute(thread);
}
// 阻塞当前线程，CountDownLatch计数减为0时表示所有线程都执行完毕，才会释放主线程的阻塞
latch.await();
System.out.println("所有线程执行完成!");
}
}
class MyThread implements Runnable {
private String name;
private CountDownLatch latch;
public MyThread(String name, CountDownLatch latch) {
this.name = name;
this.latch = latch;
}
@Override
public void run() {
// TODO 执行业务
// 随机延迟，模拟线程耗时
try {
Thread.sleep(1000 + new Random().nextInt(2000));
} catch (InterruptedException e) {
}
// 计数减一
latch.countDown();
System.out.println(name + "执行完毕...");
}
}
如何实现java主线程等待子线程执行完毕之后再执行
java.util.concurrent.CountDownLatch 这个类可以实现你所要的功能
例如：CountDownLatch latch = new CountDownLatch(5) //声明计数器为5个
Thread t = new Thread() {
public void run() {
try {
//TODO 你的应用
} catch (Exception e) {
//TODO 异常处理
}
finally {
latch.countDown(); //这句是关键
System.out.println("ok"); //5个线程都跑完后输出
}
}
};
t.start();
然后让以上操作循环五次(就是说同时开5个线程)，那么这个"ok"就会在等到这5个线程都ok后才会被输出一次。
java主线程结束和子线程结束
你应该换成main函数运行，abcd就一定会打印出来了
问题并不是出在主线程和子线程身上，事实上Java似乎也没有严格主线程和子线程的概念，取而代之的是普通线程和后台线程
但是这里你采用@Test来运行代码，而@Test是JUnit测试框架使用的注解，JUnit在进行单元测试的时候，如果被@Test注释的方法执行完成，那么内部开启的线程也会被强制退出，退出是测试框架进行的操作
这和Java承诺的普通线程不退出程序就不结束是不相符的，如果书上告诉你会输出两个但是你执行了只输出了一个那么很可能就是这里出了问题
而通过main函数则没有框架干预，根据Java的规则只要有普通线程没有退出，程序就不会完全退出（System.exit强制自杀除外），那么除非创建的线程被设置成了后台线程（或者叫守护线程，daemon），那么才会在主线程退出时自动关闭这些后台线程，就是你遇到的偶尔可以输出abcd偶尔不行的效果，否则一定会abcd和efgh两个都输出，只不过输出顺序可能不一致
关于java子线程执行完毕和main线程会等待子线程执行结束吗的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。
发布于：2022-12-18，除非注明，否则均为原创文章，转载请注明出处。