多线程（一）FutureTask简单介绍_futuretask多线程-CSDN博客

本文深入解析了FutureTask在Java多线程中的应用，介绍了其作为异步计算任务的特性，包括状态转换、执行流程及如何通过Callable接口实现计算。同时，展示了FutureTask的构造方法、get方法的使用，以及如何通过ExecutorService进行任务调度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

- 多线程（一）FutureTask简单介绍
- - 一、FutureTask介绍
  - - 1.1 FutureTask 的继承机制如下：
    - 1.2 FutureTask的使用如下：

多线程（一）FutureTask简单介绍

一、FutureTask介绍

FutureTask是一种可以取消的异步的计算任务。它的计算是通过Callable实现的，并且有三个状态：等待、运行和完成。完成包括所有计算以任意的方式结束，包括正常结束、取消和异常。

get(): 阻塞等待
get(long timeout, TimeUnit unit): 阻塞特定时间，返回其结果

1.1 FutureTask 的继承机制如下：

public class FutureTask<V> implements RunnableFuture<V> {
    /**
     * The run state of this task, initially NEW.  The run state
     * transitions to a terminal state only in methods set,
     * setException, and cancel.  During completion, state may take on
     * transient values of COMPLETING (while outcome is being set) or
     * INTERRUPTING (only while interrupting the runner to satisfy a
     * cancel(true)). Transitions from these intermediate to final
     * states use cheaper ordered/lazy writes because values are unique
     * and cannot be further modified.
     *
     * Possible state transitions:
     * 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; //任务已中断
    
    ……

    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }
    ……
    
    public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }
    
    /**
     * @throws CancellationException {@inheritDoc}
     */
    public V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
        if (unit == null)
            throw new NullPointerException();
        int s = state;
        if (s <= COMPLETING &&
            (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
            throw new TimeoutException();
        return report(s);
    }
}

public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

public interface Future<V> {

    boolean cancel(boolean mayInterruptIfRunning);

    boolean isCancelled();

    boolean isDone();

    V get() throws InterruptedException, ExecutionException;
    
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

1.2 FutureTask的使用如下：

Callable<List> bannerListCallable = () -> adService.queryIndex();
FutureTask<List> bannerTask = new FutureTask<>(bannerListCallable);
executorService.submit(bannerTask);
//Awaits completion or aborts on interrupt or timeout.
entity.put("banner", bannerTask.get()); // 阻塞，等待执行完成返回结果。