java线程中断 interrupt详解
概述：
java在运行线程的时候，我们应该有效的停止线程的运行。比如一个Activity中有个线程是无限循环的，假如每次退出activity的时候，不能有效的关闭线程的话（Activity销毁，分线程还是存在的），那么每次再次进入Activity的时候，都会创建新的分线程，这样越来越多的分线程大量的消耗者CPU资源，从而导致程序运行越来越慢，所以我们要有效的关闭分线程的运行。
一、正常运行一段代码
先运行一段代码：
class ATask implements Runnable{
private double d = 0.0;
public void run() {
//死循环执行打印"I am running!" 和做消耗时间的浮点计算
while (true) {
System.out.println("I am running!");
for (int i = 0; i < 900000; i++) {
d = d + (Math.PI + Math.E) / d;
}
//给线程调度器可以切换到其它进程的信号
Thread.yield();
}
}
}
public class InterruptTaskTest {
public static void main(String[] args) throws Exception{
//将任务交给一个线程执行
Thread t = new Thread(new ATask());
t.start();
//运行一断时间中断线程
Thread.sleep(100);
System.out.println("****************************");
System.out.println("Interrupted Thread!");
System.out.println("****************************");
t.interrupt();
}
}
运行结果：
...... I am running! I am running! I am running! I am running! **************************** Interrupted Thread! **************************** I am running! I am running! I am running! I am running! I am running! ....
运行这个程序，我们发现调用interrupt()后，程序仍在运行，如果不强制结束，程序将一直运行下去。
也就是线程并没有停止运行，所以我们单独的调用interrupt()方法是不可以的。
二、当线程等待某些事件发生而被阻塞，又会发生什么？当然，如果线程被阻塞，它便不能核查共享变量，也就不能停止。这在许多情况下会发生，例如调用Object.wait()、ServerSocket.accept()和DatagramSocket.receive()时，这里仅举出一些。
他们都可能永久的阻塞线程。即使发生超时，在超时期满之前持续等待也是不可行和不适当的，所以，要使用某种机制使得线程更早地退出被阻塞的状态。
1、分线程如果处于Object.wait, Thread.join和Thread.sleep三种方法之一阻塞的情况下，我们调用interrupt()方法的话，就会抛出中断异常（InterruptedException），从而提早地终结被阻塞状态。
class ATask implements Runnable{
private double d = 0.0;
public void run() {
//死循环执行打印"I am running!" 和做消耗时间的浮点计算
try {
while (true) {
System.out.println("I am running!");
for (int i = 0; i < 900000; i++) {
d = d + (Math.PI + Math.E) / d;
}
//休眠一断时间,中断时会抛出InterruptedException
Thread.sleep(50);
}
} catch (InterruptedException e) {
System.out.println("ATask.run() interrupted!");
}
}
}
因此，如果线程被上述几种方法阻塞，正确的停止线程方式是设置共享变量，并调用
interrupt()
（注意变量应该先设置）。如果线程没有被阻塞，这时调用
interrupt()
将不起作用；否则，线程就将得到异常（该线程必须事先预备好处理此状况），接着逃离阻塞状态。在任何一种情况中，最后线程都将检查共享变量然后再停止。
boolean flag = true;
class ATask implements Runnable{
private double d = 0.0;
public void run() {
//死循环执行打印"I am running!" 和做消耗时间的浮点计算
try {
while (flag) {
System.out.println("I am running!");
for (int i = 0; i < 900000; i++) {
d = d + (Math.PI + Math.E) / d;
}
//休眠一断时间,中断时会抛出InterruptedException
Thread.sleep(50);
}
} catch (InterruptedException e) {
System.out.println("ATask.run() interrupted!");
}
}
}
如果要停止线程的话，就设置flag=false，当循环到flag为false的话，结束线程。2、以上说的是被 Object.wait, Thread.join 和 Thread.sleep这些阻塞的情况，那么假如是Socket阻塞和I/O阻塞的话又是什么情况呢？
运行一段代码：
public class BlockingThreadTest {
static boolean flag = true;
/**
* @param args
*/
public static void main(String[] args) {
Service mService = new Service();
Thread t = new Thread(mService);
t.start();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
flag = false;
t.interrupt();
}
static class Service implements Runnable{
ServerSocket mServerSocket;
@Override
public void run() {
try {
mServerSocket = new ServerSocket(5020);
while(flag){
System.out.println("接收socket");
Socket socket = mServerSocket.accept();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
我们通过
flag = false; t.interrupt();这两种方式试图中断Thread，但是还是没有起到作用，那么我们应该用什么方式呢？
public class BlockingThreadTest {
static boolean flag = true;
/**
* @param args
*/
public static void main(String[] args) {
Service mService = new Service();
Thread t = new Thread(mService);
t.start();
try {
Thread.sleep(3000);
flag = false;
t.interrupt();
mService.mServerSocket.close();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (IOException e) {
}
}
static class Service implements Runnable {
ServerSocket mServerSocket;
@Override
public void run() {
try {
mServerSocket = new ServerSocket(5020);
while (flag) {
System.out.println("接收socket");
Socket socket = mServerSocket.accept();
}
} catch (IOException e) {
System.out.println("线程阻塞被结束，线程结束");
}
}
}
}
对就是用了
mService.mServerSocket.close();通过关闭Socket来切断阻塞，从而终止线程