【转载】Java多线程，判断其他线程是否结束的三种方法

Java多线程，判断其他线程是否结束的三种方法

参考与：https://www.cnblogs.com/will-shun/p/7392619.html

参考于：https://www.cnblogs.com/aboutblank/p/3631453.html

 

方法1：thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。

比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。

t.join();      //调用join方法，等待线程t执行完毕
t.join(1000);  //等待 t 线程，等待时间是1000毫秒。

public class TestJoin implements Runnable {


    public static void main(String[] sure) throws InterruptedException {
        Thread t = new Thread(new TestJoin());
        long start = System.currentTimeMillis();
        t.start();
        t.join(1000);//等待线程t 1000毫秒
        System.out.println(System.currentTimeMillis()-start);//打印出时间间隔
        System.out.println("Main finished");//打印主线程结束
    }

    @Override
    public void run() {
       // synchronized (currentThread()) {
            for (int i = 1; i <= 5; i++) {
                try {
                    sleep(1000);//睡眠5秒，循环是为了方便输出信息
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("睡眠" + i);
            }
            System.out.println("TestJoin finished");//t线程结束
        }
    //}
}

方法2：通过同步类CountDownLatch判断当前线程的线程组中活动线程的数目，为0时其他线程运行完毕。

同步辅助类：

    CountDownLatch是一个同步辅助类，在jdk5中引入，它允许一个或多个线程等待其他线程操作完成之后才执行。    

实现原理 ：

    CountDownLatch是通过计数器的方式来实现，计数器的初始值为线程的数量。每当一个线程完成了自己的任务之后，就会对计数器减1，当计数器的值为0时，表示所有线程完成了任务，此时等待在闭锁上的线程才继续执行，从而达到等待其他线程完成任务之后才继续执行的目的。

CountDownLatch实践

司机和工人，工人必须等到司机来了才能装货上车，司机必须得等到所有工人把货物装上车了之后才能把车开走。

同步类代码：

import java.util.concurrent.CountDownLatch;

public class Worker implements Runnable {
 
    private String workerCode;
 
    private CountDownLatch startLatch;
    private CountDownLatch latch;
 
    Worker(CountDownLatch startLatch, CountDownLatch latch, String workerCode) {
        this.startLatch = startLatch;
        this.latch = latch;
        this.workerCode = workerCode;
    }
 
    public void run() {
        try {
            startLatch.await();
            doWork();
            latch.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
 
    private void doWork() {
        System.out.println("Worker " + workerCode + " is loading goods...");
    }
}

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Driver {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch startLatch = new CountDownLatch(1);
        CountDownLatch latch = new CountDownLatch(10);
        ExecutorService executor = Executors.newFixedThreadPool(10);
 
        for(int i=0; i<10; i++) {
            executor.execute(new Worker(startLatch, latch, "worker" + i));
        }
 
        System.out.println("Driver is here.");
 
        startLatch.countDown();
 
        System.out.println("Workers get to work.");
 
        latch.await();
 
        System.out.println("Driver is ready to go.");
 
        executor.shutdown();
    }
}

方法3：通过java.util.concurrent.Executors中的方法创建一个线程池，用这个线程池来启动线程。启动所有要启动的线程后，执行线程池的shutdown()方法，即在所有线程执行完毕后关闭线程池。然后通过线程池的isTerminated()方法，判断线程池是否已经关闭。线程池成功关闭，就意味着所有线程已经运行完毕了。

线程池方法示例代码：

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  

public class Test {  
  
    public static void main(String args[]) throws InterruptedException {  
        ExecutorService exe = Executors.newFixedThreadPool(50);  
        for (int i = 1; i <= 5; i++) {  
            exe.execute(new SubThread(i));  
        }  
        exe.shutdown();  
        while (true) {  
            if (exe.isTerminated()) {  
                System.out.println("结束了！");  
                break;  
            }  
            Thread.sleep(200);  
        }  
    }  
}

一个思路：

给所有的线程加上同步（同一个锁），主线程在启动其他所有线程后wait()。每个线程运行结束后，执行notify()方法。设定一个值为其他线程数量的int计数器count，写一个while循环，循环条件为count-->0，循环内容为wait()。则所有线程运行结束后正好while循环结束。

致命缺陷：如果几个线程同时运行结束，有可能在主线程还没运行时，已经执行了好几次notify()方法。如果这样的话，while循环就永远不会结束了，主线程一直wait()下去。