「java结束子线程」主线程结束子线程

本篇文章给大家谈谈java结束子线程，以及主线程结束子线程对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、java 如何实现等待子线程结束
• 2、java主线程结束和子线程结束
• 3、java 主线程结束，子线程会结束吗
• 4、Java父线程停止时如何也将子线程停止
• 5、Java如何等待子线程执行结束
• 6、Java主线程如何等待子线程执行结束

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主线程结束和子线程结束

你应该换成main函数运行，abcd就一定会打印出来了

问题并不是出在主线程和子线程身上，事实上Java似乎也没有严格主线程和子线程的概念，取而代之的是普通线程和后台线程

但是这里你采用@Test来运行代码，而@Test是JUnit测试框架使用的注解，JUnit在进行单元测试的时候，如果被@Test注释的方法执行完成，那么内部开启的线程也会被强制退出，退出是测试框架进行的操作

这和Java承诺的普通线程不退出程序就不结束是不相符的，如果书上告诉你会输出两个但是你执行了只输出了一个那么很可能就是这里出了问题

而通过main函数则没有框架干预，根据Java的规则只要有普通线程没有退出，程序就不会完全退出（System.exit强制自杀除外），那么除非创建的线程被设置成了后台线程（或者叫守护线程，daemon），那么才会在主线程退出时自动关闭这些后台线程，就是你遇到的偶尔可以输出abcd偶尔不行的效果，否则一定会abcd和efgh两个都输出，只不过输出顺序可能不一致

java 主线程结束，子线程会结束吗

如果你说的是“进程”的话，那么就会退出。一个进程的退出，那么其里面的所有东西都会释放。 但是，如果你是在一个进程里面，建立线程P，然后再在线程P里面创建并且运行线程C1、c2等，那么，当线程P退出的时候，线程c1 c2是不会退出的。

Java父线程停止时如何也将子线程停止

从某种程度上讲，做不到。

不管是父线程还是子线程，这只不过是在运行时谁建了谁时用的，一旦所谓的字线程被启动，这两个线程是没有先后贵贱区分的。

任何线程是没有办法把另外一个线程终止的。

如果你一定想你说的那样是线的话，下面是唯一个可行方案。在"父线程"建立“子线程”时，把“父线程”的instance传过去，在“子线程”里，不停的check"父线程"是否还存活，如果否，停止。

相反的，如果"父线程"需要在"子线程"终了时结束，在"父线程"建立“子线程”时，留住“子线程”的instance然后keep

checking

whether

it's

still

alive.

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主线程如何等待子线程执行结束

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结束子线程的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于主线程结束子线程、java结束子线程的信息别忘了在本站进行查找喔。