Java任务超时处理

Java任务超时处理

有时候有一些比较耗时的操作,可能会遇到超时等问题,比如IO阻塞,Http请求得不到响应,从而出现timeout的结果。
可以想出一种解决方案:不超时返回正常结果,超时返回默认结果或者特殊处理的结果。
JDK中有此种解决方案了。

MyTask.java

package cn.pangpython.test.utils;

import java.util.Random;
import java.util.concurrent.*;

/**
 * Created by pangPython on 2017/9/21.
 */
public class MyTask {
    //设置超时时间
    private int timeout;

    public MyTask(int timeout) {
        this.timeout = timeout;
    }

    //处理我的任务
    public String handler(){
        String result = "-1";

        ExecutorService executorService = Executors.newCachedThreadPool();

        FutureTask<String> futureTask = new FutureTask<String>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                /**
                 * 这里边可以做一些耗时的操作或者发送http之类的,有可能造成超时的任务
                 *
                 */
                Random random = new Random();
                int random_num = Math.abs(random.nextInt())%4000;
                System.out.println("random_num: "+random_num);
                Thread.sleep(random_num);
                return Integer.toString(random_num);
            }
        });
        //执行
        executorService.execute(futureTask);

        try {
            //获取结果
                result = futureTask.get(timeout,TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            //如果被中断
            System.out.println("InterruptedException");
            futureTask.cancel(true);
        } catch (ExecutionException e) {
           // 如果执行异常
            System.out.println("ExecutionException");
            futureTask.cancel(true);
        } catch (TimeoutException t){
            //如果超时
            System.out.println("time out!");
            result = "0";
            futureTask.cancel(true);
        } finally {
            //关闭
            executorService.shutdown();
        }

        return result;
    }
    public static void main(String[] args){
        //声明并实例化一个自己的任务,设置超时时间为3秒
        MyTask myTask = new MyTask(3000);
        //循环5次,测试,每次使用随机数在4000范围内,如果休眠时间大于3000,则会进入超时处理逻辑
        String result;
        for(int i = 0;i<5;i++){
            System.out.println("=======第"+i+"次========");
            result = myTask.handler();
            System.out.println(result);
        }

    }
}

测试效果

这里写图片描述

  • 0
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java开发中,我们常常需要处理一些耗时的任务,比如网络请求、文件读写、复杂计算等等。这些任务如果不能在规定时间内完成,就会导致程序出现阻塞或者超时的情况。为了避免这种情况的发生,我们需要实现一个Java任务超时处理机制。 下面我将介绍一种比较简单的实现方式,希望对大家有所帮助。 1. 创建一个FutureTask对象 首先,我们需要创建一个FutureTask对象来封装我们的任务FutureTaskJava提供的一个用于异步计算的类,它可以在任务完成后获取计算结果。我们可以通过传递一个Callable对象给FutureTask来构造一个异步任务。 例如,我们要执行一个耗时的函数calculate(),则可以这样创建FutureTask对象: ``` Callable<Integer> callable = new Callable<Integer>() { @Override public Integer call() throws Exception { return calculate(); } }; FutureTask<Integer> futureTask = new FutureTask<>(callable); ``` 2. 创建一个线程来执行任务 接下来,我们需要创建一个线程来执行任务。我们可以使用线程池来管理线程,这样可以避免频繁地创建和销毁线程。在这个例子中,我们创建了一个只有一个线程的线程池。 ``` ExecutorService executorService = Executors.newSingleThreadExecutor(); executorService.submit(futureTask); ``` 3. 设置超时时间并获取结果 现在,我们需要设置一个超时时间,并在规定时间内获取任务的结果。如果超时了,则需要取消任务。 ``` try { Integer result = futureTask.get(500, TimeUnit.MILLISECONDS); System.out.println("计算结果:" + result); } catch (InterruptedException | ExecutionException | TimeoutException e) { System.out.println("计算超时或出现异常:" + e.getMessage()); futureTask.cancel(true); } ``` 在这个例子中,我们设置了超时时间为500毫秒。如果任务在规定时间内完成,就会输出计算结果;否则,就会输出计算超时或出现异常,并取消任务。 完整代码如下: ``` 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; public class TimeoutDemo { public static void main(String[] args) { Callable<Integer> callable = new Callable<Integer>() { @Override public Integer call() throws Exception { return calculate(); } }; FutureTask<Integer> futureTask = new FutureTask<>(callable); ExecutorService executorService = Executors.newSingleThreadExecutor(); executorService.submit(futureTask); try { Integer result = futureTask.get(500, TimeUnit.MILLISECONDS); System.out.println("计算结果:" + result); } catch (InterruptedException | ExecutionException | TimeoutException e) { System.out.println("计算超时或出现异常:" + e.getMessage()); futureTask.cancel(true); } executorService.shutdown(); } private static int calculate() throws InterruptedException { Thread.sleep(1000); return 1 + 1; } } ``` 在这个例子中,我们模拟了一个耗时的函数calculate(),它会休眠1秒钟,然后返回2。由于我们设置了500毫秒的超时时间,因此任务超时并输出计算超时或出现异常。 这就是Java任务超时处理机制的实现方式。通过使用FutureTask和线程池,我们可以很方便地处理耗时的任务,并在规定时间内获取计算结果。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值