Runnable、Callable、Future、FutureTask

在使用Executors创建并管理线程池的时候，我们可能会用到Runnable、Callable、Future、FutureTask等。那么接下来，就对它们一一讲解：

Runnable：

Runnable是我们常用的创建线程的接口，它只有一个run函数，没有返回值。

 * * @author  Arthur van Hoff * @see     java.lang.Thread * @see     java.util.concurrent.Callable * @since   JDK1.0 */@FunctionalInterfacepublic 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();}

Callable：

Callable是有返回值的线程接口，他只有一个call函数。

 * * @see Executor * @since 1.5 * @author Doug Lea * @param <V> the result type of method {@code call} */@FunctionalInterfacepublic 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;}

Futrue:

Executor是Runable和Callable的调度器。Future就是对Runnable或Callable任务进行取消、获取结果、判断是否完成、判断是否取消等。get方法会阻塞，直到返回结果。

get(long timeout, TimeUnit unit)方法设置了一个超时时间，超过这个时间仍然没有返回结果，则抛出超时异常。

* @see FutureTask * @see Executor * @since 1.5 * @author Doug Lea * @param <V> The result type returned by this Future's {@code get} method */public interface Future<V> {    /**     * Attempts to cancel execution of this task.  This attempt will     * fail if the task has already completed, has already been cancelled,     * or could not be cancelled for some other reason. If successful,     * and this task has not started when {@code cancel} is called,     * this task should never run.  If the task has already started,     * then the {@code mayInterruptIfRunning} parameter determines     * whether the thread executing this task should be interrupted in     * an attempt to stop the task.     *     * <p>After this method returns, subsequent calls to {@link #isDone} will     * always return {@code true}.  Subsequent calls to {@link #isCancelled}     * will always return {@code true} if this method returned {@code true}.     *     * @param mayInterruptIfRunning {@code true} if the thread executing this     * task should be interrupted; otherwise, in-progress tasks are allowed     * to complete     * @return {@code false} if the task could not be cancelled,     * typically because it has already completed normally;     * {@code true} otherwise     */    boolean cancel(boolean mayInterruptIfRunning);    /**     * Returns {@code true} if this task was cancelled before it completed     * normally.     *     * @return {@code true} if this task was cancelled before it completed     */    boolean isCancelled();    /**     * Returns {@code true} if this task completed.     *     * Completion may be due to normal termination, an exception, or     * cancellation -- in all of these cases, this method will return     * {@code true}.     *     * @return {@code true} if this task completed     */    boolean isDone();    /**     * Waits if necessary for the computation to complete, and then     * retrieves its result.     *     * @return the computed result     * @throws CancellationException if the computation was cancelled     * @throws ExecutionException if the computation threw an     * exception     * @throws InterruptedException if the current thread was interrupted     * while waiting     */    V get() throws InterruptedException, ExecutionException;    /**     * Waits if necessary for at most the given time for the computation     * to complete, and then retrieves its result, if available.     *     * @param timeout the maximum time to wait     * @param unit the time unit of the timeout argument     * @return the computed result     * @throws CancellationException if the computation was cancelled     * @throws ExecutionException if the computation threw an     * exception     * @throws InterruptedException if the current thread was interrupted     * while waiting     * @throws TimeoutException if the wait timed out     */    V get(long timeout, TimeUnit unit)        throws InterruptedException, ExecutionException, TimeoutException;}

FutureTask:

FutrueTask继承了RunnableFuture接口。然而，RunnableFuture又继承了Runnable和Future两个接口。

* @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> {    /*     * Revision notes: This differs from previous versions of this     * class that relied on AbstractQueuedSynchronizer, mainly to     * avoid surprising users about retaining interrupt status during     * cancellation races. Sync control in the current design relies     * on a "state" field updated via CAS to track completion, along     * with a simple Treiber stack to hold waiting threads.     *     * Style note: As usual, we bypass overhead of using     * AtomicXFieldUpdaters and instead directly use Unsafe intrinsics.     */    /**     * 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;