JDK 源码解析：深入浅出异步任务 FutureTask

/** * A {@link Future} that is {@link Runnable}. Successful execution of * the {@code run} method causes completion of the {@code Future} * and allows access to its results. *  * @see FutureTask * @see Executor * @since 1.6 * @author Doug Lea * @param <V> The result type returned by this Future's {@code get} method */public interface RunnableFuture<V> extends Runnable, Future<V> {    /**     * Sets this Future to the result of its computation     * unless it has been cancelled.     */    void run();}

/** * A cancellable asynchronous computation.  * * @since 1.5 * @author Doug Lea * @param <V> The result type returned by this FutureTask's {@code get} methods */public class FutureTask<V> implements RunnableFuture<V>

/** * An object that executes submitted {@link Runnable} tasks. * * @since 1.5 * @author Doug Lea */public interface Executor {

    void execute(Runnable command);}

// The run state of this task, initially NEW.// 任务的执行状态，初始为 NEW。private volatile int state;

/** The underlying callable; nulled out after running */// 需要执行的任务，任务执行完后为空private Callable<V> callable;

/** The result to return or exception to throw from get() */// 任务的执行结果，或者任务抛出的异常private Object outcome; // non-volatile, protected by state reads/writes

/** The thread running the callable; CASed during run() */// 执行任务的线程private volatile Thread runner;

/** Treiber stack of waiting threads */// 指向栈顶的指针，栈结构用于存储等待任务执行结果的线程private volatile WaitNode waiters;

// Unsafe mechanicsprivate static final sun.misc.Unsafe UNSAFE;private static final long stateOffset;private static final long runnerOffset;private static final long waitersOffset;static {    try {        UNSAFE = sun.misc.Unsafe.getUnsafe();        Class<?> k = FutureTask.class;        stateOffset = UNSAFE.objectFieldOffset            (k.getDeclaredField("state"));        runnerOffset = UNSAFE.objectFieldOffset            (k.getDeclaredField("runner"));        waitersOffset = UNSAFE.objectFieldOffset            (k.getDeclaredField("waiters"));    } catch (Exception e) {        throw new Error(e);    }}

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

NEW -> COMPLETING -> NORMALNEW -> COMPLETING -> EXCEPTIONALNEW -> CANCELLEDNEW -> INTERRUPTING -> INTERRUPTED

public boolean isCancelled() {    return state >= CANCELLED; // CANCELLED、INTERRUPTING、INTERRUPTED}

public boolean isDone() {    return state != NEW;}

/** Treiber stack of waiting threads */private volatile WaitNode waiters; // 栈顶指针

/** * Simple linked list nodes to record waiting threads in a Treiber * stack.  See other classes such as Phaser and SynchronousQueue * for more detailed explanation. */static final class WaitNode {    volatile Thread thread; // 等待任务执行结果的线程    volatile WaitNode next; // 栈的下一个节点    WaitNode() { thread = Thread.currentThread(); }}

/** * Creates a {@code FutureTask} that will, upon running, execute the * given {@code Callable}. * * @param  callable the callable task * @throws NullPointerException if the callable is null */public FutureTask(Callable<V> callable) {    if (callable == null)        throw new NullPointerException();    this.callable = callable;    this.state = NEW;       // ensure visibility of callable}

/** * Creates a {@code FutureTask} that will, upon running, execute the * given {@code Runnable}, and arrange that {@code get} will return the * given result on successful completion. * * @param runnable the runnable task * @param result the result to return on successful completion. If * you don't need a particular result, consider using * constructions of the form: * {@code Future<?> f = new FutureTask<Void>(runnable, null)} * @throws NullPointerException if the runnable is null */public FutureTask(Runnable runnable, V result) {    this.callable = Executors.callable(runnable, result);    this.state = NEW;       // ensure visibility of callable}

@Testpublic void executors() throws Exception {    Callable<String> callable = Executors.callable(new Runnable() {        @Override        public void run() {            System.out.println("run!");        }    }, "haha");    String call = callable.call();    System.out.println("call = " + call);}

run!call = haha