Callable 和 Future接口 学习

* Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。

* Callable和Runnable有几点不同：

* （1）Callable规定的方法是call()，而Runnable规定的方法是run().

* （2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。

* （3）call()方法可抛出异常，而run()方法是不能抛出异常的。

* （4）运行Callable任务可拿到一个Future对象，

* Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。

* 通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。

例子：

public class TimeOut {
    public static void main(String[] args){
        int timeout = 2; //秒.
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Boolean result = false;
        Future<Boolean> future = executor.submit(new MyJob("请求参数=="));// 将任务提交到线程池中
        try {
            result = future.get(timeout*10000, TimeUnit.MILLISECONDS);// 设定在200毫秒的时间内完成
            System.out.println(result);
        } catch (InterruptedException e) {
            System.out.println("线程中断出错。");
            future.cancel(true);// 中断执行此任务的线程
        } catch (ExecutionException e) {
            System.out.println("线程服务出错。");
            future.cancel(true);// 中断执行此任务的线程
        } catch (TimeoutException e) {// 超时异常
            System.out.println("超时。");
            future.cancel(true);// 中断执行此任务的线程
        }finally{
            System.out.println("线程服务关闭。");
            executor.shutdown();
        }
    }  

    static class MyJob implements Callable<Boolean> {
        private String t;
        public MyJob(String temp){
            this.t= temp;
        }
        public Boolean call() {
            //调整i大小测试超时
            for(int i=0;i<999999999;i++){
                if(i==2){
                    System.out.println(t);
                }
                if (Thread.interrupted()){ //很重要
                    return false;
                }
            }
            System.out.println("继续执行..........");
            return true;
        }
    }
}
 

 public class TimeoutTest1 {

    public static void main(String[] args) {
        final ExecutorService service = Executors.newFixedThreadPool(1);
        TaskThread taskThread = new TaskThread();
        System.out.println("提交任务...begin");
        Future<Object> 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<Object> {
    public Object call() throws Exception {
        String result = "空结果";
        try {
            System.out.println("任务开始....");
            //修改sleep 的值测试超时
            Thread.sleep(500);
            result = "正确结果";
            System.out.println("任务结束....");
        } catch (Exception e) {
            System.out.println("Task is interrupted!");
        }
        return result;
    }
}