Callable 和 Future接口 学习

Posted 2020-08-07

* 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;
    }
}