第七章：取消与关闭——Java并发编程实战

Java没有提供任何机制来安全地终止线程（虽然Thread.stop和suspend方法提供了这样的机制，但由于存在缺陷，因此应该避免使用

中断：一种协作机制，能够使一个线程终止另一个线程的当前工作

立即停止会使共享的数据结构处于不一致的状态，需要停止时，发出中断请求，被要求中断的线程处理完他当前的任务后会自己判断是否停下来

一、任务取消

若外部代码能在某个操作正常完成之前将其置入“完成”状态，则还操作是可取消的。（用户请求取消、有时间限制的操作<并发查找结果，一个线程找到后可取消其他线程>、应用程序事件、错误、关闭）

取消策略：详细地定义取消操作的“How”、“When”以及“What”，即其他代码如何（How）请求取消该任务，任务在何时（When）检查是否已经请求了取消，以及在响应取消请求时应该执行哪些（What）操作

举例：设置volatile变量为取消标志，每次执行前检查

private volatile boolean canceled;
    
    @Override
    public void run() {
        BigInteger p = BigInteger.ONE;
        while (!canceled){
            p = p.nextProbablePrime();
            synchronized (this) { //同步添加素数
                primes.add(p);
            }
        }
    }

注意：这是一个有问题的取消方式，若线程阻塞在add操作后，那么即使设置了取消状态，它也不会运行到检验阻塞状态的代码，因此会永远阻塞

1、中断

　　线程可以通过这种机制来通知另一个线程，告诉它在合适的或者可能的情况下停止当前工作，并转而执行其他的工作。（在取消之外的其他操作使用中断都是不合适的）

　　调用interrupt并不意味者立即停止目标线程正在进行的工作，而只是传递了请求中断的消息。会在下一个取消点中断自己，如wait, sleep,join等

public class Thread {
     public void interrupt() { ... }//中断目标线程，恢复中断状态
     public boolean isInterrupted() { ... }//返回目标线程的中断状态
     public static boolean interrupted() { ... }//清除当前线程的中断状态，并返回它之前的值（用于已经设置了中断状态，但还尚未相应中断）
     ...
 }

阻塞库方法，例如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方法，该方法允许在等待一个锁的同时仍能响应中断。

//改写interrupt方法发出中断请求   
 @Override
    public void interrupt() {
        try {
            socket.close(); //中断前关闭socket
        } catch (IOException e) {
            
        } finally{
            super.interrupt();
        }
    }

6、采用newTaskFor来封装非标准的取消

二、停止基于线程的服务

应用程序通常会创建基于线程的服务，如线程池。这些服务的时间一般比创建它的方法更长。

• 服务退出 -> 线程需要结束  无法通过抢占式的方法来停止线程，因此它们需要自行结束
• 除非拥有某个线程，否则不能对该线程进行操控。例如，中断线程或者修改线程的优先级等
• 线程池是其工作者线程的所有者，如果要中断这些线程，那么应该使用线程池
• 应用程序可以拥有服务，服务也可以拥有工作者线程，但应用程序不能拥有工作者线程，因此应用程序不能直接停止工作者线程。

服务应该生命周期方法关闭它自己以及他拥有的线程

• 要服务的存在时间大于创建线程的方法的存在时间，那么就应该提供生命周期方法
• ExecutorService提供的shutdown(), shutdownNow()

1、示例：日志服务

// LogWriter就是一个基于线程的服务，但不是一个完成的服务
public class LogWriter {
    //日志缓存
    private final BlockingQueue<String> queue;
    private final LoggerThread logger;//日志写线程
private static final int CAPACITY = 1000;

    public LogWriter(Writer writer) {
        this.queue = new LinkedBlockingQueue<String>(CAPACITY);
        this.logger = new LoggerThread(writer);
    }

public void start() { logger.start(); }

    //应用程序向日志缓存中放入要记录的日志
    public void log(String msg) throws InterruptedException {
        queue.put(msg);
}

    //日志写入线程，这是一个多生产者，单消费者的设计
    private class LoggerThread extends Thread {
        private final PrintWriter writer;
        public LoggerThread(Writer writer) {
            this.writer = new PrintWriter(writer, true); // autoflush
        }
        public void run() {
            try {
                while (true)
                   writer.println(queue.take());
            } catch(InterruptedException ignored) {
            } finally {
                writer.close();
            }
        }
    }
}

注意：可以中断阻塞的take()方法停止日志线程（消费者线程），但生产者没有专门的线程，没办法取消

//日志服务，提供记录日志的服务，并有管理服务生命周期的相关方法
public class LogService {
       private final BlockingQueue<String> queue;
       private final LoggerThread loggerThread;// 日志写线程
       private final PrintWriter writer;
       private boolean isShutdown;// 服务关闭标示
       // 队列中的日志消息存储数量。我们不是可以通过queue.size()来获取吗？
       // 为什么还需要这个？请看后面
       private int reservations;

       public LogService(Writer writer) {
              this.queue = new LinkedBlockingQueue<String>();
              this.loggerThread = new LoggerThread();
              this.writer = new PrintWriter(writer);

       }

       //启动日志服务
       public void start() {
              loggerThread.start();
       }

       //关闭日志服务
       public void stop() {
              synchronized (this) {
                     /*
                      * 为了线程可见性，这里一定要加上同步，当然volatile也可，
                      * 但下面方法还需要原子性，所以这里就直接使用了synchronized，
                      * 但不是将isShutdown定义为volatile
                      */
                     isShutdown = true;
              }
              //向日志线程发出中断请求
              loggerThread.interrupt();
       }

       //供应用程序调用，用来向日志缓存存放要记录的日志信息
       public void log(String msg) throws InterruptedException {
              synchronized (this) {
                     /*
                      * 如果应用程序发出了服务关闭请求，则不存在接受日志，而是直接
                      * 抛出异常，让应用程序知道
                      */
                     if (isShutdown)
                            throw new IllegalStateException(/*日志服务已关闭*/);
                     /*
                      * 由于queue是线程安全的阻塞队列，所以不需要同步（同步也可
                      * 但并发效率会下降，所以将它放到了同步块外）。但是这里是的
                      * 操作序列是由两个操作组成的：即先判断isShutdown，再向缓存
                      * 中放入消息，如果将queue.put(msg)放在同步外，则在多线程环
                      * 境中，LoggerThread中的  queue.size() == 0 将会不准确，所
                      * 以又要想queue.put不同步，又要想queue.size()计算准确，所
                      * 以就使用了一个变量reservations专用来记录缓存中日志条数，
                      * 这样就即解决了同步queue效率低的问题，又解决了安全性问题，
                      * 这真是两全其美
                      */
                     //queue.put(msg);
                     ++reservations;//存储量加1
              }
              queue.put(msg);
       }

       private class LoggerThread extends Thread {
              public void run() {
                     try {
                            while (true) {
                                   try {
                                          synchronized (LogService.this) {
                                                 // 由于 queue 未同步，所以这里不能使用queue.size
                                                 //if (isShutdown && queue.size() == 0)

                                                 // 如果已关闭，且缓存中的日志信息都已写入，则退出日志线程
                                                 if (isShutdown && reservations == 0)
                                                        break;
                                          }
                                          String msg = queue.take();
                                          synchronized (LogService.this) {
                                                 --reservations;
                                          }
                                          writer.println(msg);
                                   } catch (InterruptedException e) { /* 重试 */
                                   }
                            }
                     } finally {
                            writer.close();
                     }
              }
       }
}

注意：通过原子方式来检查关闭请求，并且有条件地递增一个计数器来“保持”提提交消息的权利

2、关闭ExecutorService

　　shutdown()：启动一次顺序关闭，执行完以前提交的任务，没有执行完的任务继续执行完

　　shutdownNow()：试图停止所有正在执行的任务（向它们发出interrupt操作语法，无法保证能够停止正在处理的任务线程，但是会尽力尝试），并暂停处理正在等待的任务，并返回等待执行的任务列表。

　　ExecutorService已关闭，再向它提交任务时会抛RejectedExecutionException异常

3、“毒丸”对象——当得到这个对象时，立即停止

　　在提交“毒丸”对象之前提交的所有工作都会被处理，而生产者在提交了“毒丸”对象后，将不会再提交任何工作

4、只执行一次的服务

　　如果某个方法需要处理一批任务，并且当所有任务都处理完成后才返回，那么可以通过一次私有的Executor来简化服务的生命周期管理，其中该Executor的生命周期是由这个方法来控制的。

boolean checkMail(Set<String> hosts, long timeout, TimeUnit unit)
        throws InterruptedException {
ExecutorService exec = Executors.newCachedThreadPool();
//这里不能使用 volatile hasNewMail，因为还需要在匿名内中修改
    final AtomicBoolean hasNewMail = new AtomicBoolean(false);
    try {
        for (final String host : hosts)//循环检索每台主机
            exec.execute(new Runnable() {//执行任务
                public void run() {
                   if (checkMail(host))
                       hasNewMail.set(true);
                }
            });
    } finally {
        exec.shutdown();//因为ExecutorService只在这个方法中服务，所以完成后即可关闭
        exec.awaitTermination(timeout, unit);//等待任务的完成，如果超时还未完成也会返回
    }
    return hasNewMail.get();
}

5、shutdown的局限性

我们无法通过常规方法来找出哪些任务已经开始但尚未结束。这意味着我们无法在关闭过程中知道正在执行的任务的状态，除非任务本身会执行某种检查

public class TrackingExecutor extends AbstractExecutorService {
    private final ExecutorService exec;
    private final Set<Runnable> tasksCancelledAtShutdown =
            Collections.synchronizedSet(new HashSet<Runnable>());

    public TrackingExecutor(ExecutorService exec) {
        this.exec = exec;
    }

    public List<Runnable> getCancelledTasks() {//返回被取消的任务
        if (!exec.isTerminated())//如果shutdownNow未调用或调用未完成时
            throw new IllegalStateException(/*...*/);
        return new ArrayList<Runnable>(tasksCancelledAtShutdown);
    }

    public void execute(final Runnable runnable) {
        exec.execute(new Runnable() {
            public void run() {
                try {
                    runnable.run();
                            /*参考：http://blog.csdn.net/coslay/article/details/48038795
                             * 实质上在这里会有线程安全性问题，存在着竞争条件，比如程序刚
                             * 好运行到这里，即任务任务（run方法）刚好运行完，这时外界调用
                             * 了shutdownNow()，这时下面finally块中的判断会有出错，明显示
                             * 任务已执行完成，但判断给出的是被取消了。如果要想安全，就不
                             * 应该让shutdownNow在run方法运行完成与下面判断前调用。我们要
                             * 将runnable.run()与下面的if放在一个同步块、而且还要将
                             *  shutdownNow的调用也放同步块里并且与前面要是同一个监视器锁，
                             *  这样好像就可以解决了，不知道对不能。书上也没有说能不能解决，
                             *  只是说有这个问题！但反过来想，如果真的这样同步了，那又会带
                             *  性能上的问题，因为什么所有的任务都会串形执行，这样还要
                             *  ExecutorService线程池干嘛呢？我想这就是后面作者为什么所说
                             *  这是“不可避免的竞争条件”
                             */
                } finally {
                                   //如果调用了shutdownNow且运行的任务被中断
                    if (isShutdown()
                            && Thread.currentThread().isInterrupted())
                        tasksCancelledAtShutdown.add(runnable);//记录被取消的任务
                }
            }
        });
}
// 将ExecutorService 中的其他方法委托到exec
}

三、处理非正常的线程终止

　　在一个线程中启动另一个线程，另一个线程中抛出异常，如果没有捕获它，这个异常也不会传递到父线程中

　　任何代码都可能抛出一个RuntimeException。每当调用另一个方法时，都要对它的行为保持怀疑，不要盲目地认为它一定会正常返回，或者一定会抛出在方法原型中声明的某个已检查异常

//如果任务抛出了一个运行时异常，它将允许线程终结，但是会首先通知框架：线程已经终结
public void run() {//工作者线程的实现
    Throwable thrown = null;
    try {
        while (!isInterrupted())
            runTask(getTaskFromWorkQueue());
    } catch (Throwable e) {//为了安全，捕获的所有异常
        thrown = e;//保留异常信息
    } finally {
        threadExited(this, thrown);// 重新将异常抛给框架后终结工作线程
    }
}

未捕获异常的线程

在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方法，能够比使用终结器更好地管理资源

例外：当需要管理对象时，并且该对象持有的资源是通过本地方法获得的