励精图治---Concurrency---取消线程

线程创建后有几种情况会取消

1. 用户点击cancel取消

2. 超时取消，比如网页加载中有部分信息没被加载出来

3. 应用程序的逻辑设计，比如在多线程情况下，有一个线程找到了result，其他线程停止作业。

4. error。exception

5. 关闭程序，关闭服务

常用中断方式

while (!isCancelled)  {

        doSomething();

}

每次都去检查一下这个中断状态变量。这有个坏处，就是如果doSomething有阻塞。呵呵，可能就永远都执行不下去了。

Thread的三个方法

interrupt: 中断目标线程----------不会立即停止目标线程正在进行的工作，只是传递请求中断的消息

isInterrupted: 返回目标线程的中断状态

interrupted: 清楚当前线程的中断状态

核心点：中断是实现取消的最合理方法

while (!Thread.currentThread().isInterrupted()) {

doSomething();

}

之前的中断状态变量改成了判断线程是否被interrupte.

这里的情况是    用线程自身来中断。中断的操作也通过线程自身来进行。每个线程都有自身的中断策略。另，除非你知道这个线程的中断策略，不然不要中断这个线程。

上一个理念上实现的代码。不要考虑细节。

1.外部线程中中断

private static final ScheduledExecutorService cancelExec = ...;

public static void timedRun (Runnable r, long timeout, TimeUnit unit) {

        final Thread taskThread = Thread.currentThread();

cancelExec.schedule(new Runnable() {

                public void run() { taskThread.interrupt(); }

        }, timeout, unit);

        r.run();

}

2.在专门线程中中断任务

public static void timedRun(final Runnable r, long timeout, TimeUnit unit) throws InteruptedException {

class RethrowableTask implements Runnable {

private volatile Throwable t;

public void run() {

try { r.run(); }catch (Throwable t) { this.t = t }

}

void rethrow() {

if(t != null) throw launderThrowable(t);

}

}

RethrowableTask task = new RethrowableTask();

final Thread taskThread = new Thread(task);

taskThread.start();

cancelExec.schedule(new Runnable() {

public void run() { taskThread.interrupt(); }

}, timeout, unit);

taskThread.join(unit.toMillis(timeout)); //#这里的阻塞等待不知道是超时还是正常退出。

task.rethrow();

}

通过Future来实现取消

当取消某个任务时，不宜直接中断任务，因为不知道现在执行的是什么任务。

public static void timedRun(Runnable r, long timeout, TimeUnit unit) throws InterruptedException {

Future<?> task = taskExec.submit(r);//#通过ExecutorService得到封装的Future

try {

task.get(timeout, unit);//#定时get

} catch (TimeoutException e) {

doSomething();

}catch(ExecutionException e){

doSomething();

throw launderThrowable(e.getCause());

}finally{

task.cancel(true);

}

}

处理不可中断的阻塞

1. java.io包中的同步Socket I/O: 这里个InputStream和OutputStream中的read和write不会相应中断，但这个基于套接字socket的。那么直接关闭这个套接字socket即可。这会抛出一个SocketException

2. Java.io包中的同步I/O: InterruptibleChannel 用来表现一个可以被异步关闭的 Channel 。这表现在两方面：

1．    当一个 InterruptibleChannel 的 close() 方法被调用时，其它 block 在这个 InterruptibleChannel 的 IO 操作上的线程会接收到一个 AsynchronousCloseException 。

2．    当一个线程 block 在 InterruptibleChannel 的 IO 操作上时，另一个线程调用该线程的 interrupt() 方法会导致 channel 被关闭，该线程收到一个ClosedByInterruptException ，同时线程的 interrupt 状态会被设置。

3. Selector的异步I/O: 如果一个线程在调用Selector.select方法时阻塞，那么调用close或者wakeup会使线程抛出ClosedSelectorException并提前返回。

4. 获取某个锁:可以使用lockInterruptibly方法中断

范例

public class ReaderThread extends Thread {

private final Socket socket;

private final InputStream in;

public ReaderThread(Socket socket) throws IOException {

this.socket = socket;

this.in = socket.getInputStream();

}

public void interrupt() {

try {

socket.close();

}catch(IOException ignored) {}

finally {

super.interrupter();

}

}

public void run() {

try {

byte[] buf = new byte[BUFSZ];

while(true) {

int count = in.read(buf);

if(count < 0) break;

else if(count > 0)

processBuffer(buf, count);

}

}catch(IOException e){}

}

}

另外，可以用newTaskFor来封装非标准的取消。

logger服务

范例：一段支持关闭，支持将队列中已有log信息打印出来的代码

public class LogService {

private final BlockingQueue<String> queue;

private final LoggerThread loggerThread;

private final PrintWriter writer;

@GuardedBy("this") private boolean isShutdown;

@GuardedBy("this") private int reservations;

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

public void stop() {

synchronized (this) {isShutdown = true; }

loggerThread.interrupt();

}

public void log(String msg) throws InterruptedException  {

synchronized (this) {

if(isShutdown) throw new IllegalStateException(...);

++reservations;

}

queue.put(msg);

}

private class LoggerThread extends Thread {

public void run() {

try {

while(true) {

try {

synchronized (LogService.this) {

if (isShutdown && reservations == 0) break;

}

String msg = queue.take();

synchronized(LogService.this) { --reservations; }

writer.println(msg);

}catch(InterruptedException e) { .... }

}

} finally {

writer.close();

}

}

}

}

毒丸对象

适用情况：在生产者和消费者的数量已知的情况下， 才 可以使用。除非完全确定可以保证这个 毒丸对象 不会被阻塞。不然就只能在无界队列中才能安全的使用。

public class IndexingService {
    private static final File POISON = new FIle("");
    private final IndexerThread consumer = new IndexerThread();
    private final CrawlerThread producer = new CrawlerThread();
    private final BlockingQueue<File queue;
    private final FileFilter filterFilter;
    private final File root;
    
    class CrawlerThread extends Thread {
        public void run() {
            try {
                crawl(root);
            } catch (InterruptedException e) { /**/ }
            finally {
                try {
                    queue.put(POISON);//#在某些情况下，put poison   如果这个queue超了，那可能永远都要阻塞等待下去
                } catch (InterruptedException e) { /**/ }
            }
        }
    }
    
    public class IndexerThread extends Thread {
        public void run() {
            try {
                while (true) {
                    File file = queue.take();
                    if (file == POISON)
                        break;
                    else
                        indexFile(file);
                }
            }catch(InterruptedException e) {}
        }
    }
    
    public void start() {
        producer.start();
        consumer.start();
    }
    
    public void stop() {
        producer.interrupt();
    }
    
    public void awaitTermination() throws InterruptedException {
        consumer.join();
    }
}

使用Executors完成一次性任务的关闭

public void someMethod() {
ExecutorService exec = Executors.newCachedThreadPool();
try{
doSomething();
} finally {
exec.shutdown();
exec.awaitTermination(timeout, unit);
}
}

shutdownNow的局限性：会取消正在执行的任务。我们就需要将这些任务保存起来或者写入日志，方便对这些进行处理。

线程在被关闭时，我们无法知道哪些线程被关闭，故  一定要在线程内部对这些状态进行处理。。。。封装还是很重要的。

处理非正常关闭的线程，可以通过Thread.UncaughtExceptionHandler。还可以用setDefaultUncaughtExceptionHandler来设置默认的UncaughtExceptionHandler。

JVM关闭

在正常关闭中，JVM首先调用所有已注册的Shutdown hook。shutdownhook是通过Runtime.addShutdownHook注册的但尚未开始的线程。shutdownhook的调用顺序是无法确认的。JVM不会停止或者中断任何在关闭时仍然运行的应用程序线程，这些线程在最终JVM结束时，会被结束。

public void start() {
    Runtime.getRuntime().addShutdownHook(new Thread() {
        public void run() {
            try { LogService.this.stop(); }
            catch (InterruptedException ignored) {}
        }
    });
}