Java没有提供任何机制来安全地终止线程（虽然Thread.stop和suspend方法提供了这样的机制，但由于存在缺陷，因此应该避免使用
中断：一种协作机制，能够使一个线程终止另一个线程的当前工作
立即停止会使共享的数据结构处于不一致的状态，需要停止时，发出中断请求，被要求中断的线程处理完他当前的任务后会自己判断是否停下来
一、任务取消
若外部代码能在某个操作正常完成之前将其置入“完成”状态，则还操作是可取消的。（用户请求取消、有时间限制的操作<并发查找结果，一个线程找到后可取消其他线程>、应用程序事件、错误、关闭）
取消策略：详细地定义取消操作的“How”、“When”以及“What”，即其他代码如何（How）请求取消该任务，任务在何时（When）检查是否已经请求了取消，以及在响应取消请求时应该执行哪些（What）操作
举例：设置volatile变量为取消标志，每次执行前检查
1 private volatile boolean canceled;
2
3 @Override
4 public void run() {
5 BigInteger p = BigInteger.ONE;
6 while (!canceled){
7 p = p.nextProbablePrime();
8 synchronized (this) { //同步添加素数
9 primes.add(p);
10 }
11 }
12 }
注意：这是一个有问题的取消方式，若线程阻塞在add操作后，那么即使设置了取消状态，它也不会运行到检验阻塞状态的代码，因此会永远阻塞
1、中断
线程可以通过这种机制来通知另一个线程，告诉它在合适的或者可能的情况下停止当前工作，并转而执行其他的工作。（在取消之外的其他操作使用中断都是不合适的）
调用interrupt并不意味者立即停止目标线程正在进行的工作，而只是传递了请求中断的消息。会在下一个取消点中断自己，如wait, sleep,join等
1 public class Thread {
2 public void interrupt() { ... }//中断目标线程，恢复中断状态
3 public boolean isInterrupted() { ... }//返回目标线程的中断状态
4 public static boolean interrupted() { ... }//清除当前线程的中断状态，并返回它之前的值（用于已经设置了中断状态，但还尚未相应中断）
5 ...
6 }
阻塞库方法，例如Thread.sleep和Object.wait等，都会检查线程何时中断，并且在发现时提前返回。它们在响应中断时执行的操作包括 : 清除中断状态，抛出InterruptedException，表示阻塞操作由于中断而提前结束。
- 显示的检测中断!Thread.currentThread().isInterrupted()后推出
- 阻塞方法中抓到InterruptedException后退出
2、中断策略——规定线程如何解释某个中断请求——当发现中断请求时，应该做哪些工作
由于每个线程拥有各自的中断策略，因此除非你知道中断对该线程的含义，否则就不应该中断这个线程。
3、响应中断
传递异常（throws InterruptedException）
恢复中断状态，从而事调用栈的上层代码能够对其进行处理。（Thread.currentThread().interrupt();）
4、通过Future实现取消
boolean cancel(boolean mayInterruptIfRunning);
- 如果任务已完成、或已取消，或者由于某些其他原因而无法取消，则此尝试将失败，返回false
- 调用cancel时，如果调用成功，而此任务尚未启动，则此任务将永不运行
- 如果任务已经执行，mayInterruptIfRunning参数决定了是否向执行任务的线程发出interrupt操作
5、处理不可中断的阻塞——对于某些阻塞操作，只是设置了中断状态
- Java.io包中的同步Socket I/O。虽然InputStream和OutputStream中的read和write等方法都不会响应中断，但通过关闭底层的套接字，可以使得由于执行read或write等方法而被阻塞的线程抛出一个SocketException。
- Java.io包中的同步I/O。当中断一个正在InterruptibleChannel上等待的线程时，将抛出ClosedByInterruptedException）并关闭链路（这还会使得其他在这条链路上阻塞的线程同样抛出ClosedByInterruptException）。当关闭一个InterruptibleChannel时，将导致所有在链路操作上阻塞的线程抛出AsynchronousCloseException。大多数标准的Channel都实现了InterruptibleChannel。
- Selector的异步I/O。如果一个线程在调用Selector.select方法（在java.nio.channels中）时阻塞了，那么调用close或wakeup方法会使线程抛出ClosedSelectorException并提前返回。
- 获取某个锁。如果一个线程由于等待某个内置锁而被阻塞，那么将无法响应中断，因为线程认为它肯定获得锁，所以将不会理会中断请求。但是，在Lock类中提供了lockInterruptibly方法，该方法允许在等待一个锁的同时仍能响应中断。
1 //改写interrupt方法发出中断请求
2 @Override
3 public void interrupt() {
4 try {
5 socket.close(); //中断前关闭socket
6 } catch (IOException e) {
7
8 } finally{
9 super.interrupt();
10 }
11 }
6、采用newTaskFor来封装非标准的取消
二、停止基于线程的服务
应用程序通常会创建基于线程的服务，如线程池。这些服务的时间一般比创建它的方法更长。
- 服务退出 -> 线程需要结束 无法通过抢占式的方法来停止线程，因此它们需要自行结束
- 除非拥有某个线程，否则不能对该线程进行操控。例如，中断线程或者修改线程的优先级等
- 线程池是其工作者线程的所有者，如果要中断这些线程，那么应该使用线程池
- 应用程序可以拥有服务，服务也可以拥有工作者线程，但应用程序不能拥有工作者线程，因此应用程序不能直接停止工作者线程。
服务应该生命周期方法关闭它自己以及他拥有的线程
- 要服务的存在时间大于创建线程的方法的存在时间，那么就应该提供生命周期方法
- ExecutorService提供的shutdown(), shutdownNow()
1、示例：日志服务
1 // LogWriter就是一个基于线程的服务，但不是一个完成的服务
2 public class LogWriter {
3 //日志缓存
4 private final BlockingQueue<String> queue;
5 private final LoggerThread logger;//日志写线程
6 private static final int CAPACITY = 1000;
7
8 public LogWriter(Writer writer) {
9 this.queue = new LinkedBlockingQueue<String>(CAPACITY);
10 this.logger = new LoggerThread(writer);
11 }
12
13 public void start() { logger.start(); }
14
15 //应用程序向日志缓存中放入要记录的日志
16 public void log(String msg) throws InterruptedException {
17 queue.put(msg);
18 }
19
20 //日志写入线程，这是一个多生产者，单消费者的设计
21 private class LoggerThread extends Thread {
22 private final PrintWriter writer;
23 public LoggerThread(Writer writer) {
24 this.writer = new PrintWriter(writer, true); // autoflush
25 }
26 public void run() {
27 try {
28 while (true)
29 writer.println(queue.take());
30 } catch(InterruptedException ignored) {
31 } finally {
32 writer.close();
33 }
34 }
35 }
36 }
注意：可以中断阻塞的take()方法停止日志线程（消费者线程），但生产者没有专门的线程，没办法取消
1 //日志服务，提供记录日志的服务，并有管理服务生命周期的相关方法
2 public class LogService {
3 private final BlockingQueue<String> queue;
4 private final LoggerThread loggerThread;// 日志写线程
5 private final PrintWriter writer;
6 private boolean isShutdown;// 服务关闭标示
7 // 队列中的日志消息存储数量。我们不是可以通过queue.size()来获取吗？
8 // 为什么还需要这个？请看后面
9 private int reservations;
10
11 public LogService(Writer writer) {
12 this.queue = new LinkedBlockingQueue<String>();
13 this.loggerThread = new LoggerThread();
14 this.writer = new PrintWriter(writer);
15
16 }
17
18 //启动日志服务
19 public void start() {
20 loggerThread.start();
21 }
22
23 //关闭日志服务
24 public void stop() {
25 synchronized (this) {
26 /*
27 * 为了线程可见性，这里一定要加上同步，当然volatile也可，
28 * 但下面方法还需要原子性，所以这里就直接使用了synchronized，
29 * 但不是将isShutdown定义为volatile
30 */
31 isShutdown = true;
32 }
33 //向日志线程发出中断请求
34 loggerThread.interrupt();
35 }
36
37 //供应用程序调用，用来向日志缓存存放要记录的日志信息
38 public void log(String msg) throws InterruptedException {
39 synchronized (this) {
40 /*
41 * 如果应用程序发出了服务关闭请求，则不存在接受日志，而是直接
42 * 抛出异常，让应用程序知道
43 */
44 if (isShutdown)
45 throw new IllegalStateException(/*日志服务已关闭*/);
46 /*
47 * 由于queue是线程安全的阻塞队列，所以不需要同步（同步也可
48 * 但并发效率会下降，所以将它放到了同步块外）。但是这里是的
49 * 操作序列是由两个操作组成的：即先判断isShutdown，再向缓存
50 * 中放入消息，如果将queue.put(msg)放在同步外，则在多线程环
51 * 境中，LoggerThread中的 queue.size() == 0 将会不准确，所
52 * 以又要想queue.put不同步，又要想queue.size()计算准确，所
53 * 以就使用了一个变量reservations专用来记录缓存中日志条数，
54 * 这样就即解决了同步queue效率低的问题，又解决了安全性问题，
55 * 这真是两全其美
56 */
57 //queue.put(msg);
58 ++reservations;//存储量加1
59 }
60 queue.put(msg);
61 }
62
63 private class LoggerThread extends Thread {
64 public void run() {
65 try {
66 while (true) {
67 try {
68 synchronized (LogService.this) {
69 // 由于 queue 未同步，所以这里不能使用queue.size
70 //if (isShutdown && queue.size() == 0)
71
72 // 如果已关闭，且缓存中的日志信息都已写入，则退出日志线程
73 if (isShutdown && reservations == 0)
74 break;
75 }
76 String msg = queue.take();
77 synchronized (LogService.this) {
78 --reservations;
79 }
80 writer.println(msg);
81 } catch (InterruptedException e) { /* 重试 */
82 }
83 }
84 } finally {
85 writer.close();
86 }
87 }
88 }
89 }
注意：通过原子方式来检查关闭请求，并且有条件地递增一个计数器来“保持”提提交消息的权利
2、关闭ExecutorService
shutdown()：启动一次顺序关闭，执行完以前提交的任务，没有执行完的任务继续执行完
shutdownNow()：试图停止所有正在执行的任务（向它们发出interrupt操作语法，无法保证能够停止正在处理的任务线程，但是会尽力尝试），并暂停处理正在等待的任务，并返回等待执行的任务列表。
ExecutorService已关闭，再向它提交任务时会抛RejectedExecutionException异常
3、“毒丸”对象——当得到这个对象时，立即停止
在提交“毒丸”对象之前提交的所有工作都会被处理，而生产者在提交了“毒丸”对象后，将不会再提交任何工作
4、只执行一次的服务
如果某个方法需要处理一批任务，并且当所有任务都处理完成后才返回，那么可以通过一次私有的Executor来简化服务的生命周期管理，其中该Executor的生命周期是由这个方法来控制的。
1 boolean checkMail(Set<String> hosts, long timeout, TimeUnit unit)
2 throws InterruptedException {
3 ExecutorService exec = Executors.newCachedThreadPool();
4 //这里不能使用 volatile hasNewMail，因为还需要在匿名内中修改
5 final AtomicBoolean hasNewMail = new AtomicBoolean(false);
6 try {
7 for (final String host : hosts)//循环检索每台主机
8 exec.execute(new Runnable() {//执行任务
9 public void run() {
10 if (checkMail(host))
11 hasNewMail.set(true);
12 }
13 });
14 } finally {
15 exec.shutdown();//因为ExecutorService只在这个方法中服务，所以完成后即可关闭
16 exec.awaitTermination(timeout, unit);//等待任务的完成，如果超时还未完成也会返回
17 }
18 return hasNewMail.get();
19 }
5、shutdown的局限性
我们无法通过常规方法来找出哪些任务已经开始但尚未结束。这意味着我们无法在关闭过程中知道正在执行的任务的状态，除非任务本身会执行某种检查
1 public class TrackingExecutor extends AbstractExecutorService {
2 private final ExecutorService exec;
3 private final Set<Runnable> tasksCancelledAtShutdown =
4 Collections.synchronizedSet(new HashSet<Runnable>());
5
6 public TrackingExecutor(ExecutorService exec) {
7 this.exec = exec;
8 }
9
10 public List<Runnable> getCancelledTasks() {//返回被取消的任务
11 if (!exec.isTerminated())//如果shutdownNow未调用或调用未完成时
12 throw new IllegalStateException(/*...*/);
13 return new ArrayList<Runnable>(tasksCancelledAtShutdown);
14 }
15
16 public void execute(final Runnable runnable) {
17 exec.execute(new Runnable() {
18 public void run() {
19 try {
20 runnable.run();
21 /*参考：http://blog.csdn.net/coslay/article/details/48038795
22 * 实质上在这里会有线程安全性问题，存在着竞争条件，比如程序刚
23 * 好运行到这里，即任务任务（run方法）刚好运行完，这时外界调用
24 * 了shutdownNow()，这时下面finally块中的判断会有出错，明显示
25 * 任务已执行完成，但判断给出的是被取消了。如果要想安全，就不
26 * 应该让shutdownNow在run方法运行完成与下面判断前调用。我们要
27 * 将runnable.run()与下面的if放在一个同步块、而且还要将
28 * shutdownNow的调用也放同步块里并且与前面要是同一个监视器锁，
29 * 这样好像就可以解决了，不知道对不能。书上也没有说能不能解决，
30 * 只是说有这个问题！但反过来想，如果真的这样同步了，那又会带
31 * 性能上的问题，因为什么所有的任务都会串形执行，这样还要
32 * ExecutorService线程池干嘛呢？我想这就是后面作者为什么所说
33 * 这是“不可避免的竞争条件”
34 */
35 } finally {
36 //如果调用了shutdownNow且运行的任务被中断
37 if (isShutdown()
38 && Thread.currentThread().isInterrupted())
39 tasksCancelledAtShutdown.add(runnable);//记录被取消的任务
40 }
41 }
42 });
43 }
44 // 将ExecutorService 中的其他方法委托到exec
45 }
三、处理非正常的线程终止
在一个线程中启动另一个线程，另一个线程中抛出异常，如果没有捕获它，这个异常也不会传递到父线程中
任何代码都可能抛出一个RuntimeException。每当调用另一个方法时，都要对它的行为保持怀疑，不要盲目地认为它一定会正常返回，或者一定会抛出在方法原型中声明的某个已检查异常
1 //如果任务抛出了一个运行时异常，它将允许线程终结，但是会首先通知框架：线程已经终结
2 public void run() {//工作者线程的实现
3 Throwable thrown = null;
4 try {
5 while (!isInterrupted())
6 runTask(getTaskFromWorkQueue());
7 } catch (Throwable e) {//为了安全，捕获的所有异常
8 thrown = e;//保留异常信息
9 } finally {
10 threadExited(this, thrown);// 重新将异常抛给框架后终结工作线程
11 }
12 }
未捕获异常的线程
在Thread API中提供了UncaughtExceptionHandler，它能检测出某个线程由于未捕获的异常而终结的情况
在运行时间较长的应用程序中，通常会为所有的未捕获异常指定同一个异常处理器，并且该处理器至少会将异常信息记录到日志中。
public class UEHLogger implements Thread.UncaughtExceptionHandler {
public void uncaughtException(Thread t, Throwable e) {
Logger logger = Logger.getAnonymousLogger();
logger.log(Level.SEVERE, "Thread terminated with exception: " + t.getName(), e);
}
}
四、JVM关闭
JVM既可通过正常手段来关闭，也可强行关闭。
- 正常关闭：当最后一个“正常（非守护）”线程结束时、当有人调用了System.exit时、或者通过其他特定于平台的方法关闭时
- 强行关闭：Runtime.halt，这种强行关闭方式将无法保证是否将运行关闭钩子
1、关闭钩子
- 关闭钩子是指通过Runnable.addShutdownHook注册的但尚未开始的线程
- JVM并不能保证关闭钩子的调用顺序
- 当所有的关闭钩子都执行结束时，如果runFinalizersOnExit为true，那么JVM将运行终结器（finalize），然后再停止
- JVM并不会停止或中断任何在关闭时仍然运行的应用程序线程。当JVM最终结束时，这些线程将被强行结束。如果关闭钩子或终结器没有执行完成，那么正常关闭进程“挂起”并且JVM必须被强行关闭。当被强行关闭时，只是关闭JVM，而不会运行关闭钩子
- 关闭钩子应该是线程安全的
- 关闭钩子必须尽快退出，因为它们会延迟JVM的结束时间
public void start()//通过注册关闭钩子，停止日志服务
{
Runnable.getRuntime().addShutdownHook(new Thread(){
public void run()
{
try{LogService.this.stop();}
catch(InterruptedException ignored){}
}
});
}
2、守护线程——一个线程来执行一些辅助工作，但有不希望这个线程阻碍JVM的关闭
线程可分为两种：普通线程和守护线程。在JVM启动时创建的所有线程中，除了主线程以外，其他的线程都是守护线程
普通线程与守护线程之间的差异仅在于当线程退出时发生的操作。当一个线程退出时，JVM会检查其他正在运行的线程，如果这些线程都是守护线程，那么JVM会正常退出操作。当JVM停止时，所有仍然存在的守护线程都将被抛弃——既不会执行finally代码块，也不会执行回卷栈，而JVM只是直接退出
3、终结器（清理文件句柄或套接字句柄等）——避免使用
垃圾回收器对那些定义了finalize方法的对象会进行特殊处理：在回收器释放它们后，调用它们的finalize方法，从而确保一些持久化的资源被释放。
通过使用finally代码块和显式的close方法，能够比使用终结器更好地管理资源
例外：当需要管理对象时，并且该对象持有的资源是通过本地方法获得的