JUC系列（六） | Callable和Future接口详解&使用、FutureTask应用 获取异步线程返回值

多线程一直Java开发中的难点，也是面试中的常客，趁着还有时间，打算巩固一下JUC方面知识，我想机会随处可见，但始终都是留给有准备的人的，希望我们都能加油！！！

沉下去，再浮上来，我想我们会变的不一样的。
喜欢封面的云，就是不知道你喜不喜欢

一、Callable 接口🚀

1）前言：

在上上篇文章中，创建线程那个小角落，提到了这个，但是当时只是匆匆忙忙讲了一下。到这里再全面性的讲解一下。

我们以前使用实现Runnable接口的方式来创建线程，但是Runnable的run() 存在一个缺陷问题，就是不能将执行完的结果返回。

Java就是为了能够实现这个功能，在jdk1.5中提出了Callable接口。

2）概述：

Callable 接口位于java.util.concurrent包下。

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

Callable 类似于Runnable 接口，但Runnable 接口中的run（）方法不会返回结果，并且也无法抛出经过检查的异常，但是Callable中call（）方法能够返回计算结果，并且也能够抛出经过检查的异常。

3）实现：

通过实现Callable接口创建线程详细步骤：Runnable直接看代码就知道了哈。

1. 创建实现Callable接口的类SomeCallable

2. 创建一个类对象：Callable oneCallable = new SomeCallable();

3. 由Callable创建一个FutureTask对象：FutureTask futureTask= new FutureTask(oneCallable);

   注释：FutureTask是一个包装器，它通过接受Callable来创建，它同时实现了Future和Runnable接口。

4. 由FutureTask创建一个Thread对象：Thread oneThread = new Thread(futureTask);

5. 启动线程：oneThread.start();

/**
 * @Author: crush
 * @Date: 2021-08-19 16:14
 * version 1.0
 */
public class Demo1 {
    public static void main(String[] args) {
        new Thread(new RunnableDemo1(),"AA").start();

        FutureTask<Integer> futureTask = new FutureTask<>(new CallableDemo<Integer>());
        new Thread(futureTask,"BB").start();
        // 在线程执行完后，我们可以通过futureTask的get方法来获取到返回的值。
        System.out.println(futureTask.get());
    }
}
class RunnableDemo1 implements  Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"::通过实现Runnable来执行任务");
    }
}
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 接口 🛸

2.1、概述：

Future 接口同样位于java.util.concurrent包下。

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

public interface Future<V> {

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

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

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

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

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

2.2、实现：

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

/**
 * @Author: crush
 * @Date: 2021-08-19 16:14
 * version 1.0
 */
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 🚁

3.1、FutureTask介绍

位于 java.util.concurrent包下。

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

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

FutureTask有以下三种状态：

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

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

应用场景：

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

注意：

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

使用放在下一小节啦👇

四、使用 Callable 和 Future🚩

这里的使用其实在上文已经提到过了，这里就将其更完善一些吧。

/**
 * @Author: crush
 * @Date: 2021-08-19 18:44
 * version 1.0
 */
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;
    }
}

还有很多没玩到位，大家可以继续尝试哈。

五、自言自语⛵

最近又开始了JUC的学习，感觉Java内容真的很多，但是为了能够走的更远，还是觉得应该需要打牢一下基础。

最近在持续更新中，如果你觉得对你有所帮助，也感兴趣的话，关注我吧，让我们一起学习，一起讨论吧。

你好，我是博主宁在春，Java学习路上的一颗小小的种子，也希望有一天能扎根长成苍天大树。

希望与君共勉😁

我们：待别时相见时，都已有所成。