JAVA处理线程超时

在实际业务中,由其是多线程并开业务中,经常会遇到某个线程执行超时。而程序如果不捕获这类情况,就会导致程序一直处于等待状态,从而影响后续线程的运行。
比如说网络通迅、单任务下的复杂数据库查询等,通常处理这类问题,可以启用一个后台守护线程来监控用户线程(业务线程)的执行是否超时,如果超时就不在等待,这种做法,通常是在调用用户线程的.start()方法之前,调用守护线程的start()方法,同时将超时时长传给守护线程。在守护线程的run()方法,执行sleep()方法,休眠时间为超时时长,守护线程中有一个同步后的变量用于存储用户线程是否超时。而在用户线程中,在程序执行完之后,再调用守掮线程改变同步变量。当守护线程sleep()方法之后,去有判断同步变量的值是否已改变,如果没有改变,说明用户线程还未扫行完毕,也就是超时。但这种方法,不能中断用户线程。
除此之外,还有一种方法,可以中断用户线程不在继续运行,采用java.util.concurrent下面的接口、类也可以完成。以下是例子。

Java代码 收藏代码
  1. importjava.util.concurrent.Callable;
  2. importjava.util.concurrent.ExecutionException;
  3. importjava.util.concurrent.ExecutorService;
  4. importjava.util.concurrent.Executors;
  5. importjava.util.concurrent.Future;
  6. importjava.util.concurrent.TimeUnit;
  7. importjava.util.concurrent.TimeoutException;
  8. publicclassTimeOut{
  9. publicstaticvoidmain(String[]args){
  10. inttimeout=2;//秒.
  11. ExecutorServiceexecutor=Executors.newSingleThreadExecutor();
  12. Booleanresult=false;
  13. Futurefuture=executor.submit(newMyJob("请求参数"));//将任务提交到线程池中
  14. try{
  15. result=future.get(timeout*1000,TimeUnit.MILLISECONDS);//设定在200毫秒的时间内完成
  16. System.out.println(result);
  17. }catch(InterruptedExceptione){
  18. System.out.println("线程中断出错。");
  19. future.cancel(true);//中断执行此任务的线程
  20. }catch(ExecutionExceptione){
  21. System.out.println("线程服务出错。");
  22. future.cancel(true);//中断执行此任务的线程
  23. }catch(TimeoutExceptione){//超时异常
  24. System.out.println("超时。");
  25. future.cancel(true);//中断执行此任务的线程
  26. }finally{
  27. System.out.println("线程服务关闭。");
  28. executor.shutdown();
  29. }
  30. }
  31. staticclassMyJobimplementsCallable{
  32. privateStringt;
  33. publicMyJob(Stringtemp){
  34. this.t=temp;
  35. }
  36. publicBooleancall(){
  37. for(inti=0;i<999999999;i++){
  38. if(i==999999997){
  39. System.out.println(t);
  40. }
  41. if(Thread.interrupted()){//很重要
  42. returnfalse;
  43. }
  44. }
  45. System.out.println("继续执行..........");
  46. returntrue;
  47. }
  48. }
  49. }


在做socket通信时我这边服务端需要设置超时程序(客户端为硬件终端连接,没有回应几分钟内设置超时程序)

此socket服务端启动使用timertask类型,启动后再开几十个线程来处理终端连接。。。

我试了两种超时程序都蛮好:一种是通过线程的join设置,一种是通过concurrent的Future手段

join:

publicclassThreadTest{
publicstaticvoidmain(String[]args){
CounterThreadct=newCounterThread();
ct.start();
try{
ct.join(20000);//超时的时间,如20秒
if(ct.isAlive()){//说明再设定的时间内没有执行完,超时
ct.interrupt();
throw newTimeoutException();//抛出,让socket线程终止
}
ct.getResult();//正常情况下可以获取执行后的值
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}
classCounterThreadextendsThread{
publicCounterThread(inttime){
构造函数,传递一些有用的值给run;
}
privateintresult;

publicintgetResult(){//在上面获取的结果值
returnresult;
}
publicvoidrun(){
result=执行的任务,如读取客户端数据;
}
}
Furture:

public class TimeoutTest1 {

public static void main(String[] args) {
final ExecutorService service = Executors.newFixedThreadPool(1);

TaskThread taskThread = new TaskThread();
System.out.println("提交任务...begin");
Future taskFuture = service.submit(taskThread);
System.out.println("提交任务...end");
try {
Object re = taskFuture.get(6000, TimeUnit.MILLISECONDS);//超时设置,6s
System.out.println(re);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
} catch (TimeoutException e) {
System.out.println("超时 取消任务");
taskFuture.cancel(true);
System.out.println("超时 取消任务OK");
} finally {
service.shutdown();
}

}

}

class TaskThread implements Callable {

public Object call() throws Exception {
String result = "空结果";
try {
System.out.println("任务开始....");
Thread.sleep(5000);
result = "正确结果";
System.out.println("任务结束....");
} catch (Exception e) {
System.out.println("Task is interrupted!");
}
return result;
}

}


你可能感兴趣的:(JAVA处理线程超时)