java八股文面试[多线程]——FutureTask

深碍√TFBOYSˉ_ 2024-03-08 06:56 40阅读 0赞

###### FutureTask介绍 ######

FutureTask是一个**可以取消异步**任务的类。FutureTask对Future做的一个基本实现。可以调用方法去**开始和取消**一个任务。

一般是**配合Callable**去使用。

异步任务启动之后，可以获取一个**绑定**当前异步任务的FutureTask。

可以基于FutureTask的方法去取消任务，查看任务是**否结果**，以及获取任务的**返回结果**。

FutureTask内部的整体结构中，实现了**RunnableFuture**的接口，这个接口**又继承了Runnable**, **Future**这个两个接口。所以FutureTask也**可以作为任务直接交给线程池**去处理。

![6eb4e31efd134500bc5b7493814fd17c.png][]

###### FutureTask应用 ######

大方向是FutureTask对任务的控制：

\* 任务执行过程中**状态的控制**  
\* 任务执行完毕后，**返回结果的获取**

FutureTask的任务在执行run方法后，是**无法被再次运行**，需要使用runAnd**Reset**方法才可以。

###### **FutureTask源码分析** ######

看FutureTask的源码，要从几个方向去看：

\* 先查看FutureTask中提供的一些**状态**  
\* 在查看任务的**执行过程**

FutureTask中的核心属性

清楚任务的**流转状态**是怎样的，其次对于核心属性要追到是干嘛的。

/**
     FutureTask的核心属性
     FutureTask任务的状态流转
     * NEW -> COMPLETING -> NORMAL           任务正常执行，并且返回结果也正常返回
     * NEW -> COMPLETING -> EXCEPTIONAL      任务正常执行，但是结果是异常
     * NEW -> CANCELLED                      任务被取消   
     * NEW -> INTERRUPTING -> INTERRUPTED    任务被中断
     */
    // 记录任务的状态
    private volatile int state;
    // 任务被构建之后的初始状态
    private static final int NEW          = 0;
    private static final int COMPLETING   = 1;
    private static final int NORMAL       = 2;
    private static final int EXCEPTIONAL  = 3;
    private static final int CANCELLED    = 4;
    private static final int INTERRUPTING = 5;
    private static final int INTERRUPTED  = 6;
    
    /** 需要执行任务，会被赋值到这个属性 */
    private Callable<V> callable;
    /** 任务的任务结果要存储在这几个属性中 */
    private Object outcome; // non-volatile, protected by state reads/writes
    /** 执行任务的线程 */
    private volatile Thread runner;
    /** 等待返回结果的线程Node对象， */
    private volatile WaitNode waiters;
    static final class WaitNode {
        volatile Thread thread;
        volatile WaitNode next;
        WaitNode() { thread = Thread.currentThread(); }
    }

FutureTask的run方法

任务执行前的一些判断，以及调用任务封装结果的方式，还有最后的一些后续处理

// 当线程池执行FutureTask任务时，会调用的方法
    public void run() {
        // 如果当前任务状态不是NEW，直接return告辞
        if (state != NEW ||  
            // 如果状态正确是NEW，这边需要基于CAS将runner属性设置为当前线程
            // 如果CAS失败，直接return告辞
            !UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread()))
            return;
    
        try {
            // 将要执行的任务拿到
            Callable<V> c = callable;
            // 健壮性判断，保证任务不是null
            // 再次判断任务的状态是NEW（DCL）
            if (c != null && state == NEW) {
                // 执行任务
                // result：任务的返回结果
                // ran：如果为true，任务正常结束。 如果为false，任务异常结束。
                V result;
                boolean ran;
                try {
                    // 执行任务
                    result = c.call();
                    // 正常结果，ran设置为true
                    ran = true;
                } catch (Throwable ex) {
                    // 如果任务执行期间出了异常
                    // 返回结果置位null
                    result = null;
                    // ran设置为false
                    ran = false;
                    // 封装异常结果
                    setException(ex);
                }
                if (ran)
                    // 封装正常结果
                    set(result);
            }
        } finally {
            // 将执行任务的线程置位null
            runner = null;
            // 拿到任务的状态
            int s = state;
            // 如果状态大于等于INTERRUPTING
            if (s >= INTERRUPTING)
                // 进来代表任务中断，做一些后续处理
                handlePossibleCancellationInterrupt(s);
        }
    }

当FutureTask处于**未启动或者已启动的状态时**，调用FutureTask对象的**get**方法会将导致调用线程**阻塞**。

当FutureTask处于已完成的状态时，调用FutureTask的get方法会立即放回**调用结果**或者**抛出异常**。  
当FutureTask处于**未启动**状态时，调用FutureTask对象的**cancel**方法将导致线程永远不会被执行；当FutureTask处于**已启动**状态时，调用FutureTask对象cancel(true)方法将以**中断**执行此任务的线程的方式来试图停止此任务;

当FutureTask处于**已启动**状态时，调用FutureTask对象cancel(false)方法将**不会**对正在进行的任务产生任何影响；

当FutureTask处于**已完成**状态时，调用FutureTask对象cancel方法将**返回false**；  
FutureTask的get和cancel的执行示意图

![86937ff3d6b84d6bbcbe71eed8fa8fc5.png][]

FutureTask使用  
可以把FutureTask交给**Executor**执行；也可以通**ExecutorService**.**submit**（…）方法**返回一个**FutureTask，然后执行FutureTask.get()方法或FutureTask.cancel（…）方法。除此以外，还可以单独使用FutureTask。  
当一个线程需要**等待另一个线程**把某个任务执行完后它才能继续执行，此时可以使用FutureTask。假设有多个线程执行若干任务，每个任务最多**只能被执行一次**。当多个线程试图同时执行同一个任务时，**只允许一个线程执行任务**，其他线程需要等待这个任务执行完后才能继续执行。下面是对应的示例代码。

private final ConcurrentMap<Object, Future<String>> taskCache = new ConcurrentHashMap<>();
    
        private String executionTask(final String taskName)throws ExecutionException, InterruptedException {
            while (true) {
                Future<String> future = taskCache.get(taskName); // 1.1,2.1
                if (future == null) {
                    Callable<String> task = () -> taskName;
                    FutureTask<String> futureTask = new FutureTask<>(task);
                    future = taskCache.putIfAbsent(taskName, futureTask); // 1.3
                    if (future == null) {
                        future = futureTask;
                        futureTask.run(); // 1.4执行任务
                    }
                }
                try {
                    return future.get(); // 1.5,
                } catch (CancellationException e) {
                    taskCache.remove(taskName, future);
                }
            }
        }

![9474ee6f09e34ab995d1176e899b397a.png][]

当两个线程试图同时执行同一个任务时，如果Thread 1执行1.3后Thread 2执行2.1，那么接下来Thread 2将在2.2等待，直到Thread 1执行完1.4后Thread 2才能从2.2（FutureTask.get()）返回

**FutureTask实现**  
jdk1.8的FutureTask有个说明：  
修订说明:这与这个类以前依赖**AbstractQueuedsynchronizer**的版本不同，主要是为了避免在取消竞争期间**保留中断状态**让用户感到意外。在当前的设计中，Sync控件依赖于通过**CAS**更新的“state”字段来跟踪完成，以及一个简单的Treiber堆栈来保存等待的线程。  
风格注意:与往常一样，我们**绕过了使用 AtomicXFieldUpdaters的开销**，而是**直接使用Unsafe**。

**Future**  
FutureTask实现了Future接口，Future接口有**5个方法**：  
1、boolean **cancel**(boolean mayInterruptIfRunning)  
尝试取消当前任务的执行。如果任务已经取消、已经完成或者其他原因不能取消，尝试将失败。如果任务还没有启动就调用了cancel(true)，任务将永远不会被执行。如果任务已经启动，参数**mayInterruptIfRunning**将决定任务是否应该中断执行该任务的线程，以尝试中断该任务。  
如果任务不能被取消，通常是因为它已经正常完成，此时返回false，否则返回true  
2、boolean **isCancelled**()  
如果任务在正常结束之前被被取消返回true  
3、boolean **isDone**()  
正常结束、异常或者被取消导致任务完成，将返回true  
4、V **get**()  
等待任务结束，然后获取结果，如果任务在等待过程中被终端将抛出InterruptedException，如果任务被取消将抛出CancellationException，如果任务中执行过程中发生异常将抛出ExecutionException。  
5、V **get**(long timeout, TimeUnit unit)  
任务最多在给定时间内完成并返回结果，如果没有在给定时间内完成任务将抛出TimeoutException。

###### FutureTask状态转换 ######

FutureTask有以下7中状态：

![7ab86b9fe0de4127a8164160a4046150.png][]

FutureTask任务的运行状态，最初为NEW。运行状态**仅在set**、**setException**和**cancel**方法中转换为**终端状态**。在完成过程中，状态可能呈现出**瞬时值**INTERRUPTING(仅在中断运行程序以满足**cancel(true)**的情况下)或者**COMPLETING**(在设置结果时)状态时。从这些中间状态到最终状态的转换使用**成本更低**的**有序/延迟写**，因为值是统一的，需要进一步修改。  
state：表示当前任务的运行状态，FutureTask的**所有方法都是围绕state开展的**，state声明为**volatile**，保证了state的可见性，当对state进行修改时所有的线程都会看到。

NEW：表示一个新的任务，初始状态  
COMPLETING：当任务被设置结果时，处于COMPLETING状态，这是一个**中间状态**。  
NORMAL：表示任务正常结束。  
EXCEPTIONAL：表示任务因异常而结束  
CANCELLED：任务还未执行之前就调用了cancel(true)方法，任务处于CANCELLED  
INTERRUPTING：当任务调用cancel(true)中断程序时，任务处于INTERRUPTING状态，这是一个**中间状态**。  
INTERRUPTED：任务调用cancel(true)中断程序时会调用interrupt()方法中断线程运行，任务状态由INTERRUPTING转变为INTERRUPTED

可能的**状态过渡**：  
1、NEW -> COMPLETING -> NORMAL：正常结束  
2、NEW -> COMPLETING -> EXCEPTIONAL：异常结束  
3、NEW -> CANCELLED：任务被取消  
4、NEW -> INTERRUPTING -> INTERRUPTED：任务出现中断

知识来源：

[FutureTask详解\_索码理的博客-CSDN博客][FutureTask_-CSDN]

[6eb4e31efd134500bc5b7493814fd17c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/a890bf4137494602a817e7b3c3706dcb.png
[86937ff3d6b84d6bbcbe71eed8fa8fc5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/c3e1e5bacc004cf683ca0e1a0a6cc2e0.png
[9474ee6f09e34ab995d1176e899b397a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/e82a5ddd73e245378dce9c24fcf06714.png
[7ab86b9fe0de4127a8164160a4046150.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/015e27d65b314ddeb3d6f62bfc4f52ab.png
[FutureTask_-CSDN]: https://blog.csdn.net/qq_39654841/article/details/90631795