什么是区别？
ExecutorService eService = Executors.newFixedThreadPool(2);
eService.execute(new TestThread6());
eService.execute(new TestThread6());
eService.execute(new TestThread6());
eService.awaitTermination(1, TimeUnit.NANOSECONDS);
eService.shutdown();
和
eService.shutdown();
eService.awaitTermination(1, TimeUnit.NANOSECONDS);
我不太理解shutdown()方法。这个方法不等待之前提交的任务完成执行，这是什么意思呢？shutdown()是否可能终止已提交但未完成的任务？我尝试了一些例子，但它们并没有证明它，能否给我一个例子。
在使用awaitTermination方法之前，您应该先调用shutdown方法。否则，您可能需要等待很长时间，因为awaitTermination并不会真正关闭您的执行器。
如果您希望等待任务完成而不是等待执行器关闭，则应使用invokeAll方法。
awaitTermination方法实际上并没有先关闭你的执行器。因此，除非另一个线程关闭执行器，否则awaitTermination将一直等待，直到超时时间到期。显然，在你的例子中，在超时前只等待了1纳秒，这就是为什么你没有观察到“很长时间”的原因。 - C. K. Youngshutdown() 方法不会中断已经执行的任务。根据 javadoc 的描述："启动有序关闭过程，在该过程中，先前提交的任务将被执行，但不会接受新任务。" 如果你想要中断任务的执行，应该调用 shutDownNow() 方法。 - bowmore阅读文档总是有帮助的:
尝试停止所有正在执行的任务，停止等待中的任务的处理，并返回一个执行等待的任务列表。这些任务会在从此方法返回时从任务队列中移除。
该方法不会等待正在执行的任务终止。请使用awaitTermination方法进行等待。
除了尽最大努力停止正在处理的活动任务外，没有其他保证。此实现通过Thread.interrupt()取消任务，因此任何无法响应中断的任务可能永远无法终止。
开始有序关闭，在此过程中，先前提交的任务将被执行，但不会接受新任务。如果已经关闭，则调用不会产生额外效果。
此方法不会等待先前提交的任务完成执行。使用awaitTermination方法进行等待。
在关闭请求后，阻塞直到所有任务完成执行或超时发生，或当前线程被中断，以先发生者为准。
shutdown的线程不会阻塞。 - S.D.shutdown不等待之前提交的任务完成执行”，我相信他们的意思是当前线程不会阻塞，直到之前提交的任务完成执行。 - JasonShutdown意味着执行器服务不再接受更多的任务。
AwaitTermination是在关闭请求之后调用的。
您需要首先关闭服务，然后阻塞并等待线程完成。
如果您想要看到所有线程都完成运行，并坚持使用awaiTermination，则需要将超时参数设置为足够大。所以您可以这样做：
eService.shutdown();
if (!eService.awaitTermination(60000, TimeUnit.SECONDS))
System.err.println("Threads didn't finish in 60000 seconds!");
}
或者，您可以这样做：
eService.shutdown();
while (!eService.isTerminated()) {
}
这样可以确保所有线程都能完成运行，除非它们被意外中断。
while 循环被称为“忙等待”，会使 CPU 核心一直保持在 100% 直到完成。鉴于您有 awaitTermination 方法可用，这是一种浪费。 - Igor Rodriguez最佳实现：
executor.shutdown();
try {
if (!executor.awaitTermination(3500, TimeUnit.MILLISECONDS)) {
executor.shutdownNow();
}
} catch (InterruptedException e) {
executor.shutdownNow();
}
Main Difference
shutdown()-
1. Doesn't block the calling a thread i.e. the thread who called the shutdown().
2. Excecutor doesn't accept any new task after calling shutdown().
awaitTermination() -
1. Blocks the calling thread. (as join() method do)
awaitTermination的意思是等待任务完成/终止，对吧？shutdown()也在做同样的事情——等待任何已经提交的任务以及正在运行的任务继续直到完成/终止，那么为什么还需要另一个方法awaitTermination(..)呢？以下是解释：
假设您只能等待10分钟来完成所有已提交的任务，并且在此之后想要调用shutdownNow()（---您已经知道它是做什么的了），然后在调用shutdown()之后使用awaitTermination(long timeout, TimeUnit unit)。
注意awaitTermination(long timeout, TimeUnit unit)中的方法参数。这里的超时时间是关键。
如果没有时间限制，那么shutdown()就可以了。不需要awaitTermination()。
executorService.execute(runnableTask);
//executorService.shutdown(); //it will make the executorService stop accepting new tasks
//executorService.shutdownNow(); //tires to destroy the executorService immediately, but it doesn't guarantee that all the running threads will be destroyed at the same time. This method returns list of tasks which are waiting to be processed.
//List<Runnable> notExecutedTasks = executorService.shutdownNow(); //this method returns list of tasks which are waiting to be processed.developer decide what to do with theses tasks?
//one good way to shutdown the executorService is use both of these methods combined with the awaitTermination
executorService.shutdown();
try{
if(!executorService.awaitTermination(1000, TimeUnit.MICROSECONDS)) {
executorService.shutdownNow();
}
}catch (InterruptedException e){
e.printStackTrace();
}
在启动第一个任务后，ThreadPoolExecutor将启动一个线程，即使任务完成后也不会结束。至少对于固定的线程池来说是这样。这就是为什么我们需要调用shutdown。在关闭后，ThreadPoolExecutor将拒绝任何新任务，但会等待正在运行的任务完成，然后允许线程结束。这就是为什么我们需要在关闭后使用awaitTermination。
shutdown()会停止执行器接受更多的任务，并让正在执行的任务完成。该调用不会阻塞当前线程。
awaitTermination(1, TimeUnit.NANOSECONDS)将等待执行器在给定的时间内完成执行。请注意，这是一个阻塞调用。
如果您的优先级是在终止之前让执行器完成其执行，则简单地调用shutdown()即可完成工作。
然而，在某些情况下，我们可能希望在一定时间后关闭执行器，而不管任务是否完成执行。对于这些情况，您可以使用以下方法：
Runnable runnable = () -> System.out.println("Some tasks.");
ExecutorService eService = Executors.newFixedThreadPool(2);
eService.execute(runnable);
eService.execute(runnable);
eService.execute(runnable);
eService.execute(runnable);
eService.shutdown();
try {
int waitCount = 0;
// blocking the Thread for 1 minute. If awaitTermination() returns true then executor is shutdown
while (!eService.awaitTermination(1, TimeUnit.MINUTES)) {
waitCount++;
if (waitCount == 60) { // waited for 60 minutes to complete execution
List<Runnable> runnableList = eService.shutdownNow();
System.out.println("ThreadPool forcefully shutdown with " + runnableList.size() + " tasks remaining.");
break;
}
}
} catch (InterruptedException e) {
eService.shutdownNow();
System.err.println("ThreadPool shutdown interrupted.");
Thread.currentThread().interrupt();
}
来自Java8 ThreadPool的awaitTermination方法：
try {
for (;;) {
if (runStateAtLeast(ctl.get(), TERMINATED))
return true;
if (nanos <= 0)
return false;
nanos = termination.awaitNanos(nanos);
}
} finally {
mainLock.unlock();
}
它将首先检查线程池的运行状态。如果线程池没有关闭（将运行状态设置为终止），则awaitTermination方法将不会在超时之前返回。这就解释了为什么如果您先等待再关闭，那么等待时间会很长。
awaitTermination() 方法后立即调用 shutdownNow() 方法。只有这样，你才能找出 awaitTermination() 方法的实际用途。