线程中断，interrupt，安全地终止线程

早期是stop，可以强行令一个正在运行的线程停止，不安全，已被弃用。

现在是interrupt，不会令一个正在运行的线程停止。（？）

当一个线程调用interrupt时，线程的中断标记位将被置位（置为true），线程会时不时地检测这个中断标记位，以判断线程是否应该被中断。

通过Thread.CurrentThread().isInterrupterd可以知道线程是否被置位

new Thread(new Runnable() {
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            //do something
        }
    }
}).start();

还可以调用Thread.interrupted对线程进行复位（置为false）。

但是如果一个线程被阻塞的时候，就无法检测中断状态了。如果一个线程处于阻塞状态，线程在检查中断标识位时如果发现中断标识位为true，则会在阻塞方法调用处抛出InterruptException异常，并且在抛出异常前将贤臣搞定中断标识位复位（置为false）。要注意的是被中断的线程不一定会终止。中断线程是为了引起线程的注意，被中断的线程可以决定如何去响应中断。如果是比较重要的线程就不会理会中断，而大部分情况则是线程会将中断作为一个终止的请求。另外，不要在底层代码里补货InterruptedException异常后不作处理，如下所示。

new Thread(new Runnable() {
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            //do something
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {

            }
        }
    }
}).start();

有两种合适的处理方式

复位

try {
    Thread.sleep(50);
} catch (InterruptedException e) {
    Thread.currentThread().interrupted();
}

更好的做法是

void task() throws InterruptedException{
    Thread.currentThread().sleep(50);
}

让调用者来捕获这个异常

接下来才是安全地使用interrupt终止线程（？）

Thread t =new Thread(new Runnable() {

    private long i;

    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            i ++;
            Log.i("xbh", "i = " + i);
        }
        Log.i("xbh", "stop ");
    }
});

t.start();
try {
    TimeUnit.MILLISECONDS.sleep(10);
} catch (InterruptedException e) {
    e.printStackTrace();
}
t.interrupt();

输出

12-28 02:23:10.738 10853-10899/? I/xbh: i = 334
12-28 02:23:10.738 10853-10899/? I/xbh: i = 335
12-28 02:23:10.738 10853-10899/? I/xbh: i = 336
12-28 02:23:10.738 10853-10899/? I/xbh: i = 337
12-28 02:23:10.738 10853-10899/? I/xbh: stop 

上面调用了sleep方法使得主线程睡眠了10ms，这是为了留给我们新建的这个线程一定的时间去输出i，不然直接就中断了。

其实还有一种人为的终止，通过一个boolean常量即可

class MyRunnable implements Runnable{
    private long i;
    private volatile boolean on = true;

    @Override
    public void run() {
        while (on) {
            i ++;
            Log.i("xbh", "i = " + i);
        }
        Log.i("xbh", "stop ");
    }

    public void cancle() {
        on = false;
    }
}

MyRunnable r = new MyRunnable();

Thread t = new Thread(r);

t.start();

try {
    TimeUnit.MILLISECONDS.sleep(10);
} catch (InterruptedException e) {
    e.printStackTrace();
}

r.cancle();

注意on变量是加了一个volatile关键字，因为多个线程都访问了这个变量（主线程和myRunnable），所以设置了这个关键字，当它的值变化的时候，所有的线程都会感知到它的变化。