如何判断线程池中所有线程是否执行完毕：shutdown()和awaitTermination()——普通线程用wait()和notify()方法结束和唤醒线程

判断线程池中所有线程是否执行完毕

根据线程池中的总线程数目等于完成的线程数目：pool.getTaskCount()和pool.getCompletedTaskCount()

public interface Future<V>Future 
表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。
计算完成后只能使用 get 方法来获取结果，如有必要，计算完成前可以阻塞此方法。取消则由 cancel 方法来执行。
还提供了其他方法，以确定任务是正常完成还是被取消了。
一旦计算完成，就不能再取消计算。
如果为了可取消性而使用 Future 但又不提供可用的结果，则可以声明 Future<?> 形式类型、并返回 null 作为底层任务的结果。 

pool.getTaskCount() == pool.getCompletedTaskCount()

package com.luna.thread;
import java.util.Random;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadsIsDone {
	public static void main(String[] args) {
		// 创建一个10个线程的线程池
		ThreadPoolExecutor pool = new ThreadPoolExecutor(10, 10, 0L, TimeUnit.MILLISECONDS,
				new LinkedBlockingQueue<Runnable>());
 
		for (int i = 0; i < 10; i++) {
			pool.submit(new Runnable() {
				public void run() {
				System.out.println(
		                "当前线程:" + Thread.currentThread().getName() + ",打印随机数:" + new Random().nextInt(1000));
				}
			});
		}
		System.out.println("pool.getTaskCount():" + pool.getTaskCount());
		System.out.println("pool.getCompletedTaskCount():" + pool.getCompletedTaskCount());
		//当线程池完成的线程数等于线程池中的总线程数
		boolean allThreadsIsDone = pool.getTaskCount() == pool.getCompletedTaskCount();
		
		System.out.println(allThreadsIsDone);//是否全部完成
		
		if (allThreadsIsDone) {
			System.out.println("全部执行完成");
		}
		while (!allThreadsIsDone) {
			allThreadsIsDone = pool.getTaskCount() == pool.getCompletedTaskCount();
			if (allThreadsIsDone) {
				System.out.println("全部执行完成");
			}
		}
	}
}

当调用ExecutorService的shutdown()和awaitTermination()

• shutdown方法：这个方法会平滑地关闭ExecutorService，当我们调用这个方法时，ExecutorService 停止接受任何新的任务且等待已经提交的任务执行完成(已经提交的任务会分两类：一类是已经在执行的，另一类是还没有开始执行的)，当所有已经提交的任务执行完毕后将会关闭ExecutorService。

• awaitTermination方法：接收人timeout和TimeUnit两个参数，用于设定超时时间及单位。当等待超过设定时间时，会监测ExecutorService是否已经关闭，若关闭则返回true，否则返回false。一般情况下会和shutdown方法组合使用。

ExecutorService service = Executors.newFixedThreadPool(4);  
service.submit(new Task1());  
service.submit(new Task1());  
service.submit(new LongTask());  
service.submit(new Task1());  
  
service.shutdown();  
  
while (!service.awaitTermination(1, TimeUnit.SECONDS)) {  
    System.out.println("线程池没有关闭");  
}  
System.out.println("线程池已经关闭");  

这段代码中，我们在第三次提交了一个长任务(这个任务将执行10秒沉睡)，紧跟着执行了一次shutdown()方法，假设：这时ExecutorService被立即关闭，下面调用service.awaitTermination(1, TimeUnit.SECONDS)方法时应该返回true，程序执行结果应该只会打印出：“线程池已经关闭”。但是，真实的运行结果如下：

这说明我们假设错误，service.awaitTermination(1, TimeUnit.SECONDS)每隔一秒监测一次ExecutorService的关闭情况，而长任务正好需要执行10秒，因此会在前9秒监测时ExecutorService为未关闭状态，而在第10秒时已经关闭，因此第10秒时输出：线程池已经关闭。这也验证了shutdown方法关闭ExecutorService的条件(shutdown方法：所有已经提交的任务执行完毕后将会关闭ExecutorService)。

package com.luna.thread;
import java.util.Random;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadDone {
	public static void main(String[] args) {
		// 创建一个10个线程的线程池
		ThreadPoolExecutor pool = new ThreadPoolExecutor(10, 10, 0L, TimeUnit.MILLISECONDS,
				new LinkedBlockingQueue<Runnable>());
		for (int i = 0; i < 10; i++) {
			pool.submit(new Runnable() {
				public void run() {
				System.out.println(
				"当前线程:" + Thread.currentThread().getName() + ",打印随机数:" + new Random().nextInt(1000));
				}
			});
		}
		pool.shutdown();
		try {
			pool.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("all thread complete");
	}
}

isTerminated()

当需要用到isTerminated()函数判断线程池中的所有线程是否执行完毕时候，不能直接使用该函数，必须在shutdown()方法关闭线程池之后才能使用，否则isTerminated()永不为TRUE，线程将一直阻塞在该判断的地方，导致程序最终崩溃。

• isShutDown()：当调用shutdown()或shutdownNow()方法后返回为true。
• isTerminated()：当调用shutdown()方法后，并且所有提交的任务完成后返回为true;
  isTerminated：当调用shutdownNow()方法后，成功停止后返回为true;

如果线程池任务正常完成，都为false

• shutdownNow方法：这个方法会强制关闭ExecutorService，它将取消所有运行中的任务和在工作队列中等待的任务，这个方法返回一个List列表，列表中返回的是等待在工作队列中的任务。

ExecutorService service = Executors.newFixedThreadPool(3);   
service.submit(new LongTask());   
service.submit(new LongTask());   
service.submit(new LongTask());   
service.submit(new LongTask());   
service.submit(new LongTask());   
  
List<Runnable> runnables = service.shutdownNow();   
System.out.println(runnables.size());   
  
while (!service.awaitTermination(1, TimeUnit.MILLISECONDS)) {   
    System.out.println("线程池没有关闭");   
}   
System.out.println("线程池已经关闭");  

这段代码中，我们限制了线程池的长度是3，提交了5个任务，这样将有两个任务在工作队列中等待，当我们执行shutdownNow方法时，ExecutorService被立刻关闭，所以在service.awaitTermination(1, TimeUnit.MILLISECONDS)方法校验时返回的是false，因此没有输出：“线程池没有关闭”。而在调用shutdownNow方法时，我们接受到了一个List，这里包含的是在工作队列中等待执行的任务，由于线程池长度为3，且执行的都是长任务，所以当提交了三个任务后线程池已经满了，剩下的两次提交只能在工作队列中等待，因此我们看到runnables的大小为2，结果如下：

• isTerminated方法：这个方法会校验ExecutorService当前的状态是否为“TERMINATED”即关闭状态，当为“TERMINATED”时返回true否则返回false

	ExecutorService service = Executors.newFixedThreadPool(3);   
  	service.submit(new ShortTask());   
  	service.submit(new ShortTask());   
  	service.submit(new LongTask());   
  	  
  	service.shutdown();   
  	System.out.println(System.currentTimeMillis());   
  	while (!service.isTerminated()) {   
  	}   
  	System.out.println(System.currentTimeMillis());  

这段代码我们执行了两个正常的任务和一个长任务，然后调用了shutdown方法，我们知道调用shutdown方法并不会立即关闭ExecutorService，这时我们记录一下监测循环执行前的时间，在没有关闭前我们一直进入一个空循环中，直到 ExecutorService关闭后退出循环，这里我们知道长任务执行时间大约为10秒，我们看一下上述程序运行结果：

这10秒正好是长任务执行的时间，因此在 ExecutorService正常关闭后isTerminated方法返回true。

• isShutdown方法：这个方法在ExecutorService关闭后返回true，否则返回false。方法比较简单不再举例。
  以上讨论是基于ThreadPoolExecutor的实现，不同的实现会有所不同需注意。