Callable、Future、FutureTask一、Callable 接口 1、概述：我们以前使用实现Runnab

一、Callable 接口

1、概述：

我们以前使用实现Runnable接口的方式来创建线程，但是Runnable的run()存在一个缺陷问题，就是不能将执行完的结果返回。Java就是为了能够实现这个功能，在jdk1.5中提出了Callable接口。Callable接口位于java.util.concurrent包下。Callable 类似于Runnable接口，但Runnable接口中的run（）方法不会返回结果，并且也无法抛出经过检查的异常，但是Callable中call（）方法能够返回计算结果，并且也能够抛出经过检查的异常。

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception; //计算结果，如果无法计算则抛出异常。
}

2、实现：

public class Demo1 {
    public static void main(String[] args) {
    
        //Runnable
        new Thread(new RunnableDemo1(),"AA").start();
        
        //Callable
        //在线程执行完后，我们可以通过futureTask的get方法来获取到返回的值。
        FutureTask<Integer> futureTask = new FutureTask<>(new CallableDemo<Integer>());
        new Thread(futureTask,"BB").start();
        System.out.println(futureTask.get());
    }
}

//Runnable
class RunnableDemo1 implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"::通过实现Runnable来执行任务");
    }
}

//Callable
class CallableDemo<Integer> implements Callable<java.lang.Integer> {

    @Override
    public java.lang.Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"::通过实现Callable接口来执行任务，并返回结果！");
        return 1024;
    }
}
    //执行结果：
    //AA::通过实现Runnable来执行任务
    //BB::通过实现Callable接口来执行任务，并返回结果！
    //1024

这里之所以要转成FutureTask放进Thread中去，是因为Callable本身与Thread没有关系，通过FutureTask 才能和Thread产生联系。

二、Future 接口

1、概述：

Future接口同样位于java.util.concurrent包下。Future接口提供方法来检测任务是否被执行完，等待任务执行完获得结果，也可以设置任务执行的超时时间。这个设置超时的方法就是实现Java程序执行超时的关键。

public interface Future<V> {

    //尝试取消此任务的执行。
    boolean cancel(boolean mayInterruptIfRunning); 

    //如果此任务在正常完成之前被取消，则返回true 
    boolean isCancelled();

    //如果此任务完成，则返回true 。 完成可能是由于正常终止、异常或取消——在所有这些情况下，此方法将返回true 
    boolean isDone(); 

    //获得任务计算结果
    V get() throws InterruptedException, ExecutionException; 

    //可等待多少时间去获得任务计算结果
    V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}

2、实现：

Future模式通俗点来描述就是：我有一个任务，提交给了Future，Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时间之后，我就便可以从Future那儿取出结果。

public class Demo1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        FutureTask<Integer> futureTask = new FutureTask<>(new CallableDemo<Integer>());

        new Thread(futureTask,"BB").start();
        System.out.println(futureTask.get());
        // 我们来测试一下任务是否已经完成
        System.out.println(futureTask.isDone());
    }
}

class CallableDemo<Integer> implements Callable<java.lang.Integer> {
    @Override
    public java.lang.Integer call() throws Exception {
        System.out.println(Thread.currentThread().getName()
        +"::通过实现Callable接口来执行任务，并返回结果！");
        return 1024;
    }
}

Future用于存储从另一个线程获得的结果。如果只是简单创建线程，直接使用Runnable就可以，想要获得任务返回值，就用Future。

三、 FutureTask 类

1、FutureTask介绍

位于java.util.concurrent包下。可取消的异步计算。此类提供Future的基本实现，具有启动和取消计算、查询以查看计算是否完成以及检索计算结果的方法。计算完成后才能检索结果；如果计算尚未完成， get方法将阻塞。一旦计算完成，就不能重新开始或取消计算（除非使用runAndReset调用计算）。结构图：

在这里插入图片描述

FutureTask实现了Runnable和Future接口，并方便地将两种功能组合在一起。并且通过构造函数提供Callable来创建FutureTask，就可以提供给Thread来创建线程。

FutureTask有以下三种状态：

未启动状态：还未执行run（）方法。
已启动状态：已经在执行run（）方法。
完成状态：已经执行完run（）方法，或者被取消了，亦或者方法中发生异常而导致中断结束。

2、FutureTask应用场景及注意事项

应用场景：

在主线程执行那种比较耗时的操作时，但同时又不能去阻塞主线程时，就可以将这样的任务交给FutureTask对象在后台完成，然后等之后主线程需要的时候，就可以直接get()来获得返回数据或者通过isDone（）来获得任务的状态。
一般FutureTask多应用于耗时的计算，这样主线程就可以把一个耗时的任务交给FutureTask，然后等到完成自己的任务后，再去获取计算结果。

注意事项：

仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞get方法。
一旦计算完成，就不能再重新开始或取消计算。
get方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常。
因为只会计算一次,因此通常get方法放到最后。

四、使用 Callable 和 Future


public class CallableDemo2 {

    public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
        CallableAndFutureTest callableAndFutureTest = new CallableAndFutureTest();
        FutureTask<String> task = new FutureTask<>(callableAndFutureTest);
        new Thread(task).start();
        
        //System.out.println("尝试取消任务，传true表示取消任务，false则不取消任务::"+task.cancel(true));

        System.out.println("判断任务是否已经完成::"+task.isDone());

        //结果已经计算出来，则立马取出来，如若摸没有计算出来，则一直等待，直到结果出来，或任务取消或发生异常。
        System.out.println("阻塞式获取结果::"+task.get());

        System.out.println("在获取结果时，给定一个等待时间，如果超过等待时间还未获取到结果，则会主动抛出超时异常::"+task.get(2, TimeUnit.SECONDS));

    }
}

class CallableAndFutureTest implements Callable<String> {
    @Override
    public String call() throws Exception {
        String str="";
        for (int i=0;i<10;i++){
            str+=String.valueOf(i);
            Thread.sleep(100);
        }
        return str;
    }
}