java多线程之Future接口及其FutureTesk

1.Future接口

• 无论使用Thread还是Runnable新建线程，它都无法返回结果值。而自从Jdk1.5开始，官方提供了 Callable和Future, 通过他们就可以获得任务的执行结果。其中FutureTask则作为Future的实现类。
  

1.1:位置及适用场景

• Future接口是Java标准API的一部分，在java.util.concurrent包中。
• Callable接口需要借助FutureTask类，比如获取返回结果。
• Java中需要设定代码执行的最长时间，即超时，可以用Java线程池ExecutorService类配合Future接口来实现。
• Future接口是Java线程Future模式的实现，可以来进行异步计算。

1.2:描述

• Future模式可以这样来描述：我有一个任务，提交给了Future，Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时间之后，我就便可以从Future那儿取出结果。就相当于下了一张订货单，一段时间后可以拿着提订单来提货，这期间可以干别的任何事情。其中Future 接口就是订货单，真正处理订单的是Executor类，它根据Future接口的要求来生产产品。
• Future接口提供方法来检测任务是否被执行完，等待任务执行完获得结果，也可以设置任务执行的超时时间。这个设置超时的方法就是实现Java程序执行超时的关键。

1.3：接口的方法

Future接口是一个泛型接口，严格的格式应该是Future，其中V代表了Future执行的任务返回值的类型，Future接口的方法介绍如下： 判断任务是否完成、能够中断任务、能够获取执行结果。

public interface Future<V> {
	//尝试取消此次任务  mayInterruptIfRunning - true如果执行该任务的线程应该被中断; 否则，正在进行的任务被允许完成 。
	//【任务还没有开始，mayInterruptIfRunning无论设置为true还是false, 它的返回值都为false (因为任务还没执行)。任务已结束，mayInterruptIfRunning无论设置为true还是false, 它的返回值都为false (因为任务已完成)。任务已经启动，mayInterruptIfRunning设置为true,表示中断正在运行的任务，中断成功则返回true; 若mayInterruptIfRunning设置为false表示不会去中断已经在运行的任务，返回false】
    boolean cancel(boolean mayInterruptIfRunning);
	//如果此任务在正常完成之前被取消，则返回 true 。 
    boolean isCancelled();
	//返回true如果任务已完成。 完成可能是由于正常终止，异常或取消 - 在所有这些情况下，此方法将返回true 。 
    boolean isDone();
	//等待计算完成然后返回结果，获得V类型的结果，InterruptedException 线程被中断异常，ExecutionException任务执行异常，任务被取消，还会抛出CancellationException。
    V get() throws InterruptedException, ExecutionException;
    //同上面get功能一样，多了设置超时时间。参数timeout指定超时时间，uint指定时间的单位，在枚举类TimeUnit中有相关的定义。如果计算超时，将抛出TimeoutException。
    V get(long timeout, TimeUnit unit)throws InterruptedException, ExecutionException, TimeoutException;
}

2.FutureTask

2.1:Future的实现类

• Future的实现类有java.util.concurrent.FutureTask即 javax.swing.SwingWorker<T,V>。
• FutrueTask是Futrue接口的唯一的实现类，具有启动和取消计算的方法，查询计算是否完整，并检索计算结果。 结果只能在计算完成后才能检索; 如果计算尚未完成，则get方法将阻止。 一旦计算完成，则无法重新启动或取消计算（除非使用runAndReset()调用计算 ）。
• 除了作为独立类之外，此类还提供了protected功能，在创建自定义任务类时可能很有用。
• FutureTask可用于包装Callable或Runnable对象。 因为FutureTask实现Runnable ，一个FutureTask可以提交到一个Executor执行。

2.2：构造方法和描述

FutureTask(Callable callable)；
创建一个 FutureTask ，它将在运行时执行给定的 Callable 。
FutureTask(Runnable runnable, V result)；
创建一个 FutureTask ，将在运行时执行给定的 Runnable ，并安排 get将在成功完成后返回给定的结果。
方法

2.3：方法：修饰语和类型 方法和描述

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

protected void done()
此任务转换到状态 isDone （无论是正常还是通过取消）调用的受保护方法。

V get()
等待计算完成，然后检索其结果。

V get(long timeout, TimeUnit unit)
如果需要等待最多在给定的时间计算完成，然后检索其结果（如果可用）。

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

boolean isDone()
返回 true如果任务已完成。

void run()
将此未来设置为其计算结果，除非已被取消。

protected boolean runAndReset()
执行计算而不设置其结果，然后将此将来重置为初始状态，如果计算遇到异常或被取消，则不执行此操作。

protected void set(V v)
将此未来的结果设置为给定值，除非此未来已被设置或已被取消。

protected void setException(Throwable t)
导致这个未来报告一个ExecutionException与给定的可抛弃的原因，除非这个未来已经被设置或被取消。

package com.test;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
 
class SumTotal implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 50; i++) {
            if (i%20 == 0){
                System.out.println("sleep");
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName()+"  " + i);
            }
            sum += i;
        }
        return sum;
    }
}
 
public class Main7 {
    public static void main(String[] args) {
        //实例化对象
        SumTotal sumTotal = new SumTotal();
        //创建FutureTask
        FutureTask<Integer> futureTask = new FutureTask<Integer>(sumTotal);
        //执行线程任务
        Thread thread = new Thread(futureTask);
        thread.setName("线程1");
        thread.start();

        //获取线程任务返回值
        try {
            int sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

2.4:FutureTask实现超时执行 | 案例一：

ExecutorService executor = Executors.newSingleThreadExecutor();   
FutureTask<String> future =   
       new FutureTask<String>(new Callable<String>() {//使用Callable接口作为构造参数   
         public String call() {   
           //真正的任务在这里执行，这里的返回值类型为String，可以为任意类型   
       }});   
executor.execute(future);   
//在这里可以做别的任何事情   
try {   
    result = future.get(5000, TimeUnit.MILLISECONDS); //取得结果，同时设置超时执行时间为5秒。同样可以用future.get()，不设置执行超时时间取得结果   
} catch (InterruptedException e) {   
    futureTask.cancel(true);   
} catch (ExecutionException e) {   
    futureTask.cancel(true);   
} catch (TimeoutException e) {   
    futureTask.cancel(true);   
} finally {   
    executor.shutdown();   
}  

• 不直接构造Future对象，也可以使用ExecutorService.submit方法来获得Future对象，submit方法即支持以 Callable接口类型，也支持Runnable接口作为参数，具有很大的灵活性。使用示例如下：

ExecutorService executor = Executors.newSingleThreadExecutor();   
FutureTask<String> future =　executor.submit(   
   new Callable<String>() {//使用Callable接口作为构造参数   
       public String call() {   
      //真正的任务在这里执行，这里的返回值类型为String，可以为任意类型   
   }});   
//在这里可以做别的任何事情   
//同上面取得结果的代码  

• 利用Future接口实现程序执行超时大致用法就这么多，改天需要研究下Future接口的内部实现，特别是设定执行超时的实现。

2.5:FutureTask实现超时执行 | 案例二：

• 使用方法因为FutureTask实际上是实现的RunnableFuture接口，而RunnableFuture接口其实是继承自Runnable和Future，所以其同时具有他们共同的特点，可以直接交给线程池进行执行。

ExecutorService executorService = Executors.newSingleThreadExecutor();
        FutureTask<Integer> integerFutureTask = new FutureTask<Integer>(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum=0;
                for (int i = 0; i < 10; i++) {
                    sum+=i;
                }
                return sum;
            }
        });
        executorService.execute(integerFutureTask);
        
        //获取Future的第二种方式
        Future<Integer> submit = executorService.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum=0;
                for (int i = 0; i < 10; i++) {
                    sum+=i;
                }
                return sum;
            }
        });
        System.out.println("在这里随便做什么事");
        System.out.println(integerFutureTask.get());
        
        //效果和上面相同只不过设定的最长等待时间为2s  TimeUnit用来设置时间单位
        System.out.println(integerFutureTask.get(2,TimeUnit.SECONDS));

• Future其实就相当于你把一件工作交给某个人来完成，而你最后只需要干你自己的事，到时间了找他要已经做好的成品就好了。

原文链接：https://blog.csdn.net/qq_38345606/article/details/82829400
原文链接：https://blog.csdn.net/liutong123987/article/details/79377764
原文链接：https://blog.csdn.net/qq_36761831/article/details/90517323
原文链接（推荐）：https://blog.csdn.net/TheWindOfSon/article/details/108174052