笔者在平常的项目开发中，会遇到有些程序执行时间过长的问题(比如查询数据库的时间过长，或者调用某一接口执行的时间过长)，导致程序长时间卡死，因此，需要对程序进行超时中断处理，给程序的执行时间设定一个时间范围限制，如果超过这一范围，则进行中断处理，包括中断线程并且返回超时的结果。有时候线程已经在执行了，是无法中断的，程序要返回超时的结果，只是线程会继续执行，直到线程执行完成。

下面将介绍两种超时中断处理的实现方法，方法一是本人自己利用线程实现的，方法二则利用JDK自带的工具类FutureTask。

1、方法一

import java.util.Date;

public class TaskThread extends Thread {

private Task task;

public TaskThread(Task task) {

this.task = task;

}

public void run() {

int i = 0;

while(true && i < 10){

if(Task.STATUS_INTERRUPT.equals(task.getStatus())){

System.out.println("线程执行中断");

break;

}

System.out.println(new Date().toLocaleString()+":每隔1秒打印一下日志");

try {

Thread.sleep(1*1000);

i++;

} catch (InterruptedException e) {

e.printStackTrace();

}

}

task.setStatus(Task.STATUS_FINISHED);

System.out.println("线程执行完成");

}

}

import java.util.Date;

public class Task {

public static final String STATUS_START = "START";

public static final String STATUS_FINISHED = "FINISHED";

public static final String STATUS_INTERRUPT = "INTERRUPT";

private String status = "";

private Date startTime = null;

private TaskThread taskThread = null;

public void setStatus(String status) {

this.status = status;

}

public String execute() {

this.setStatus(Task.STATUS_START);

startTime = new Date();

taskThread = new TaskThread(this);

try{

taskThread.start();

}catch (Exception e) {

e.printStackTrace();

}

String result = "";

while(true){

if(Task.STATUS_FINISHED.equals(this.getStatus())){

result = "任务执行成功";

break;

}

Date currentTime = new Date();

if((currentTime.getTime() - this.getStartTime().getTime()) > 5*1000){

this.setStatus(Task.STATUS_INTERRUPT);

result = "任务执行中断";

System.out.println("线程执行超时：限定时间是5秒!");

break;

}

}

return result;

}

public String getStatus() {

return status;

}

public Date getStartTime() {

return startTime;

}

public void setStartTime(Date startTime) {

this.startTime = startTime;

}

}

/**

* 当任务执行超时或者执行过程出现错误时，实现任务中断功能。

* @author brushli

* @date 2013-10-05

*

*/

public class InterruptExample {

public static void main(String[] args) {

Task task = new Task();

String execute = task.execute();

System.out.println("result="+execute);

}

}

程序执行的结果：

2013-10-5 15:10:45:每隔1秒打印一下日志

2013-10-5 15:10:46:每隔1秒打印一下日志

2013-10-5 15:10:47:每隔1秒打印一下日志

2013-10-5 15:10:48:每隔1秒打印一下日志

2013-10-5 15:10:49:每隔1秒打印一下日志

线程执行超时：限定时间是5秒!

result=任务执行中断

线程执行中断

线程执行完成

更改一下类Task中的代码，将超时的时间范围设定为50秒

if((currentTime.getTime() - this.getStartTime().getTime()) > 50*1000){

this.setStatus(Task.STATUS_INTERRUPT);

result = "任务执行中断";

System.out.println("线程执行超时：限定时间是50秒!");

break;

}

此时程序的执行结果是：

2013-10-5 15:12:11:每隔1秒打印一下日志

2013-10-5 15:12:12:每隔1秒打印一下日志

2013-10-5 15:12:13:每隔1秒打印一下日志

2013-10-5 15:12:14:每隔1秒打印一下日志

2013-10-5 15:12:15:每隔1秒打印一下日志

2013-10-5 15:12:16:每隔1秒打印一下日志

2013-10-5 15:12:17:每隔1秒打印一下日志

2013-10-5 15:12:18:每隔1秒打印一下日志

2013-10-5 15:12:19:每隔1秒打印一下日志

2013-10-5 15:12:20:每隔1秒打印一下日志

线程执行完成

result=任务执行成功

2、方法二

利用JDK自带的工具类：FutureTask

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.FutureTask;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.TimeoutException;

/**

* 当任务执行超时或者执行过程出现错误时，实现任务中断功能。

* @author brushli

* @date 2013-10-05

*

*/

public class InterruptTest {

public static void main(String[] args) {

System.out.println("result="+new InterruptTest().getResult());

}

public String getResult() {

ExecutorService executorService = Executors.newSingleThreadExecutor();

FutureTask future = new FutureTask(new Callable() {

public String call() throws Exception {

InterruptTest interrupt = new InterruptTest();

return interrupt.getValue();

}

});

executorService.execute(future);

String result = null;

try{

//设定超时的时间范围为10秒

result = future.get(10, TimeUnit.SECONDS);

}catch (InterruptedException e) {

future.cancel(true);

System.out.println("方法执行中断");

}catch (ExecutionException e) {

future.cancel(true);

System.out.println("Excution异常");

}catch (TimeoutException e) {

future.cancel(true);

result = "方法执行时间超时";

}

executorService.shutdownNow();

return result;

}

public String getValue()

{

try{

Thread.sleep(5000);

System.out.println("正常执行");

}catch (Exception e) {

e.printStackTrace();

}

return "正常结果";

}

}

程序运行的结果是：

正常执行

result=正常结果

修改一下超时的时间：

//设定超时的时间范围为3秒

result = future.get(3, TimeUnit.SECONDS);

程序运行的结果是：

java.lang.InterruptedException: sleep interruptedresult=方法执行时间超时

at java.lang.Thread.sleep(Native Method)

at com.interrupt.InterruptTest.getValue(InterruptTest.java:48)

at com.interrupt.InterruptTest$1.call(InterruptTest.java:23)

at com.interrupt.InterruptTest$1.call(InterruptTest.java:1)

at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303)

at java.util.concurrent.FutureTask.run(FutureTask.java:138)

at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886)

at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908)

at java.lang.Thread.run(Thread.java:662)