Java 线程池中 Future & FutureTask 使用总结

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

public interface Future<V> {

    // 尝试取消任务执行。如果这个任务已经执行完成，或者已经被取消，或者一些其他原因导致任务无法被取消，该方法操作失败；
    // 如果取消成功，并且这个任务还没有被开始执行，这个任务将永远不会再被执行；
    // 如果任务已经开始执行，将由 mayInterruptIfRunning 参数决定是否尝试中断执行该任务的线程来尝试停止任务；
    // 这个方法执行返回结果后，如果随后调用 isDone 方法将永远返回 true；如果这个方法返回true，那么随后调用 isCancelled 方法将永远返回 true；
    // mayInterruptIfRunning 为 true，中断执行任务线程，false 执行中的任务将会一直执行完毕。
    boolean cancel(boolean mayInterruptIfRunning);

    // 判断任务是否被取消
    boolean isCancelled();

    // 判断任务是否执行完毕
    boolean isDone();
    
    // 用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回
    V get() throws InterruptedException, ExecutionException;

    // 用来获取执行结果，如果在指定时间内，还没获取到结果，直接抛出 TimeoutException
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

public interface Executor {

    // 执行一个 Runnable 类型任务，无返回结果。
    void execute(Runnable command);
}

public interface ExecutorService extends Executor {

    ... ...

    // 执行一个 Callable 类型任务，并通过 Future#get() 获取执行结果。
    <T> Future<T> submit(Callable<T> task);

    // 执行一个 Runnable 类型任务，并通过 Future#get() 获取执行结果，使用比较少；
    // Runnable 类型的任务是不能返回执行结果，但是可以通过指定参数，返回执行结果。
    // 具体的实现逻辑在 RunnableAdapter 中，我理解应该是类似于通过共享变量来获取返回结果的意思。
    <T> Future<T> submit(Runnable task, T result);
    
    // 执行一个 Runnable 类型任务，并通过 Future 返回执行结果，但是返回的结果 Future#get() 为 null。
    Future<?> submit(Runnable task);

    ... ...
}

package java.util.concurrent;

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 class FutureTask<V> implements RunnableFuture<V> {
    
    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }
}

class App {

    ExecutorService executor = ...
    ArchiveSearcher searcher = ...

    void showSearch(final String target) throws InterruptedException {
        
        Future<String> future = executor.submit(new Callable<String>() {
            public String call() {
                return searcher.search(target);
            }});
        displayOtherThings(); // do other things while searching
        try {
            displayText(future.get()); // use future 
        } catch (ExecutionException ex) { 
            cleanup(); 
            return; 
        }
    
        FutureTask<String> future = new FutureTask<String>(new Callable<String>() {
            public String call() {
                return searcher.search(target);
            }
        });
        executor.execute(future);
    }
}

/**
 * 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;

// CANCELLED、INTERRUPTING、INTERRUPTED 状态都表示任务已被取消
public boolean isCancelled() {
    return state >= CANCELLED;
}

// 状态不等于 NEW 都表示任务已完成
public boolean isDone() {
    return state != NEW;
}

// 1、判断状态是否是 NEW，同时 cas 修改 state 状态值；
// 2、根据 mayInterruptIfRunning 参数决定是中断线程，还是等待线程执行完成。
public boolean cancel(boolean mayInterruptIfRunning) {
    if (!(state == NEW &&
          UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
              mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
        return false;
    try {    // in case call to interrupt throws exception
        if (mayInterruptIfRunning) {
            try {
                Thread t = runner;
                if (t != null)
                    t.interrupt();
            } finally { // final state
                UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
            }
        }
    } finally {
        finishCompletion();
    }
    return true;
}