线程，是编程中处理并发最常用的方式。但是如果用不好，也是一个比较麻烦的事情。毕竟创建一个线程是件容易的事情。但是怎么终止一个线程，却不那么容易。关于线程的退出，最好的方式当然是让线程处理完相应的工作后自动退出。其次是主线程有效的通知到工作线程，“Hello, please exit!”。当然，暴力终止是不被推荐的，可能会发生数据一致性的问题。或者，其他未知问题。
我首先能想到的通知一个线程中断，就是设置线程中断标志。
import java.io.IOException;
import java.net.ServerSocket;
public class InterruptTest {
private static boolean interrupt = false;
public static boolean getInterrupt(){
return interrupt;
}
public synchronized static void setInterupt(boolean value){
interrupt = value;
}
public void method1(){
try{
int i=1;
while(!interrupt){
System.out.println("thread continue excute " + i++);
}
}catch(Exception e){
System.out.println(e.getMessage());
}
}
public static void main(String args[]) throws InterruptedException, IOException{
InterruptTest test = new InterruptTest();
Thread thread = new Thread(new Runnable(){
@Override
public void run() {
test.method1();
}
});
thread.start();
Thread.sleep(2000);
InterruptTest.setInterupt(true);
thread.join();
System.out.println("Main thread finished!");
}
}
这种方式当然可以有效的通知一直有任务运行的线程去中断自己。但是，如果线程一直处于阻塞状态，比如Thread.sleep()。显然线程是无法及时获取中断标志的。考虑下面这种场景。这个时候就该Thread.interrupt出场了。
import java.io.IOException;
import java.net.ServerSocket;
public class InterruptTest {
private static boolean interrupt = false;
public static boolean getInterrupt(){
return interrupt;
}
public synchronized static void setInterupt(boolean value){
interrupt = value;
}
public void method1(){
try{
int i=1;
while(!interrupt){
System.out.println("thread continue excute " + i++);
}
}catch(Exception e){
System.out.println(e.getMessage());
}
}
public void method2(){
try{
int i=1;
while(!interrupt){
System.out.println("thread continue excute " + i++);
Thread.sleep(3000);
}
}catch(Exception e){
setInterupt(true);
System.out.println(e.getMessage());
}
}
public static void main(String args[]) throws InterruptedException, IOException{
InterruptTest test = new InterruptTest();
Thread thread = new Thread(new Runnable(){
@Override
public void run() {
test.method2();
}
});
thread.start();
Thread.sleep(2000);
thread.interrupt();
thread.join();
System.out.println("Main thread finished!");
}
}
输出结果为：
thread continue excute 1
sleep interrupted
Main thread finished!
Thread.sleep函数导致线程阻塞。interrput函数会发送一个java.lang.InterruptedException异常，当线程捕获这个异常就会通知线程终止循环。
但调用interrupt函数也仅仅只能让能接收InterruptedException异常的阻塞终止。其他一些I/O阻塞是不会理会interrupt函数发出的异常的。这种情况就需要针对不同的情况做处理了。比如，socket阻塞在accpet函数。interrupt函数就无能为力了。这时候就可以通过socket的close函数来关闭端口。
import java.io.IOException;
import java.net.ServerSocket;
public class InterruptTest {
private static boolean interrupt = false;
private ServerSocket socket1;
public ServerSocket getSocket(){
return socket1;
}
public static boolean getInterrupt(){
return interrupt;
}
public synchronized static void setInterupt(boolean value){
interrupt = value;
}
public void method1(){
try{
int i=1;
while(!interrupt){
System.out.println("thread continue excute " + i++);
}
}catch(Exception e){
System.out.println(e.getMessage());
}
}
public void method2(){
try{
int i=1;
while(!interrupt){
System.out.println("thread continue excute " + i++);
Thread.sleep(3000);
}
}catch(Exception e){
setInterupt(true);
e.printStackTrace();
}
}
public void method3(){
try{
System.out.println("Start to run thread!");
socket1 = new ServerSocket(8889);
socket1.accept();
System.out.println("Setup one connection!");
}catch(Exception e){
setInterupt(true);
System.out.println(e.getMessage());
}
}
public static void main(String args[]) throws InterruptedException, IOException{
InterruptTest test = new InterruptTest();
Thread thread = new Thread(new Runnable(){
@Override
public void run() {
test.method3();
}
});
thread.start();
Thread.sleep(2000);
test.getSocket().close();
thread.join();
System.out.println("Main thread finished!");
}
}
输出结果：
Start to run thread!
socket closed
Main thread finished!
其实在调用Socket.close函数的时候，socket线程会接收到一个java.net.SocketException异常。然后通过捕获这个异常，改变线程中断标志来中断线程。
总之，如何有效的中断一个线程。需要根据实际情况来处理。换到风险投资领域。进入之前就先想好退出方式。如果你的工作线程没有阻塞，就用中断标志控制就好。如果有一般阻塞，准备好处理interruptedException。如果有其他I/O阻塞，先提供阻塞对象的句柄获取方式。然后准备好处理相应的中断异常。
