「java等待线程池结束」线程池主线程等待子线程结束

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

本文目录一览：

• 1、如何等待java线程池中所有任务完成
• 2、java中，一个运行的线程什么状态是它的结束
• 3、Java 如何判断线程池所有任务是否执行完毕
• 4、Java如何等待子线程执行结束
• 5、java并发编程学习：如何等待多个线程执行完成
• 6、java 如何实现等待子线程结束

如何等待java线程池中所有任务完成

你可以使用这个CountDownLatch

public class CountDownLatchDemo {  

    final static SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  

    public static void main(String[] args) throws InterruptedException {  

        CountDownLatch latch=new CountDownLatch(2);//两个工人的协作  

        Worker worker1=new Worker("zhang san", 5000, latch);  

        Worker worker2=new Worker("li si", 8000, latch);  

        worker1.start();//  

        worker2.start();//  

        latch.await();//等待所有工人完成工作  

        System.out.println("all work done at "+sdf.format(new Date()));  

    }  

    static class Worker extends Thread{  

        String workerName;   

        int workTime;  

        CountDownLatch latch;  

        public Worker(String workerName ,int workTime ,CountDownLatch latch){  

             this.workerName=workerName;  

             this.workTime=workTime;  

             this.latch=latch;  

        }  

        public void run(){  

            System.out.println("Worker "+workerName+" do work begin at "+sdf.format(new Date()));  

            doWork();//工作了  

            System.out.println("Worker "+workerName+" do work complete at "+sdf.format(new Date()));  

            latch.countDown();//工人完成工作，计数器减一  

        }  

        private void doWork(){  

            try {  

                Thread.sleep(workTime);  

            } catch (InterruptedException e) {  

                e.printStackTrace();  

            }  

        }  

    }  

}

java中，一个运行的线程什么状态是它的结束

线程有四种状态，任何一个线程肯定处于这四种状态中的一种：

1) 产生(New)：线程对象已经产生，但尚未被启动，所以无法执行。如通过new产生了一个线程对象后没对它调用start()函数之前。

2)

可执行(Runnable)：每个支持多线程的系统都有一个排程器，排程器会从线程池中选择一个线程并启动它。当一个线程处于可执行状态时，表示它可能正处于线程池中等待排排程器启动它;也可能它已正在执行。如执行了一个线程对象的start()方法后，线程就处于可执行状态，但显而易见的是此时线程不一定正在执行中。

3) 死亡(Dead)：当一个线程正常结束，它便处于死亡状态。如一个线程的run()函数执行完毕后线程就进入死亡状态。

4)

停滞(Blocked)：当一个线程处于停滞状态时，系统排程器就会忽略它，不对它进行排程。当处于停滞状态的线程重新回到可执行状态时，它有可能重新执行。如通过对一个线程调用wait()函数后，线程就进入停滞状态，只有当两次对该线程调用notify或notifyAll后它才能两次回到可执行状态。

Java 如何判断线程池所有任务是否执行完毕

调用shutdown()，线程池就会不再接受任务。

然后调用public boolean awaitTermination(long timeout,

TimeUnit unit)

等待所有任务执行完毕，执行完毕返回true或者超时返回false。

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并发编程学习：如何等待多个线程执行完成

实现方式多种多样，下面列两种供参考：

import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.*;

public class Main {

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        System.out.println("方式1");

        System.out.println("================================================");

        // 方式1

        // 创建一个线程池，并创建10个线程放入线程池执行

        ExecutorService pool = Executors.newCachedThreadPool();

        for (int i = 0; i  10; i++) {

            pool.execute(new MyThread("线程" + i));

        }

        // 线程池不再接收新任务

        pool.shutdown();

        // 线程池中的所有线程都执行完pool.isTerminated()才返回true

        while (!pool.isTerminated()) {

            Thread.sleep(100);

        }

        System.out.println("所有线程执行完成");

        System.out.println("\n\n方式2");

        System.out.println("================================================");

        // 方式2

        ExecutorService pool2 = Executors.newCachedThreadPool();

        ListFuture futures = new ArrayList();

        for (int i = 0; i  10; i++) {

            // 使用实现Callable接口的方式创建线程，通过Future可以获取线程中返回的结果

            Future future = pool2.submit(new MyThread2("线程" + i));

            futures.add(future);

        }

        for (Future future : futures) {

            // 该方法会阻塞主线程，直到线程执行完成

            future.get();

        }

        System.out.println("所有线程执行完成");

    }

}

class MyThread extends Thread {

    private String name;

    public MyThread(String name) {

        this.name = name;

    }

    @Override

    public void run() {

        try {

            Thread.sleep(3000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        System.out.println(name + "执行完成");

    }

}

class MyThread2 implements Callable {

    private String name;

    public MyThread2(String name) {

        this.name = name;

    }

    @Override

    public Object call() throws Exception {

        try {

            Thread.sleep(3000);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

        System.out.println(name + "执行完成");

        return null;

    }

}

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等待线程池结束的信息别忘了在本站进行查找喔。