Java中的Runnable，Callable，Future，FutureTask的比较

@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();}

@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;}

* @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;}

public class FutureTask<V> implements RunnableFuture<V> {......}

/** * 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();}

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

/**   * Returns a {@link Callable} object that, when   * called, runs the given task and returns the given result. This   * can be useful when applying methods requiring a   * {@code Callable} to an otherwise resultless action.   * @param task the task to run   * @param result the result to return   * @param <T> the type of the result   * @return a callable object   * @throws NullPointerException if task null   */  public static <T> Callable<T> callable(Runnable task, T result) {    if (task == null)      throw new NullPointerException();    return new RunnableAdapter<T>(task, result);  }

/**   * A callable that runs given task and returns given result   */  static final class RunnableAdapter<T> implements Callable<T> {    final Runnable task;    final T result;    RunnableAdapter(Runnable task, T result) {      this.task = task;      this.result = result;    }    public T call() {      task.run();      return result;    }  }

package com.stay4it.rx;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;import java.util.concurrent.FutureTask;public class FutureTest {  public static class Task implements Runnable {    @Override    public void run() {      // TODO Auto-generated method stub      System.out.println("run");    }  }  public static class Task2 implements Callable<Integer> {    @Override    public Integer call() throws Exception {      System.out.println("call");      return fibc(30);    }  }   /**    * runnable, 无返回值    */   public static void testRunnable(){    ExecutorService executorService = Executors.newCachedThreadPool();    Future<String> future = (Future<String>) executorService.submit(new Task());    try {      System.out.println(future.get());    } catch (InterruptedException e) {      // TODO Auto-generated catch block      e.printStackTrace();    } catch (ExecutionException e) {      // TODO Auto-generated catch block      e.printStackTrace();    }    executorService.shutdown();  }  /**    * Callable, 有返回值    */   public static void testCallable(){    ExecutorService executorService = Executors.newCachedThreadPool();    Future<Integer> future = (Future<Integer>) executorService.submit(new Task2());    try {      System.out.println(future.get());    } catch (InterruptedException e) {      // TODO Auto-generated catch block      e.printStackTrace();    } catch (ExecutionException e) {      // TODO Auto-generated catch block      e.printStackTrace();    }    executorService.shutdown();  }   /**    * FutureTask则是一个RunnableFuture<V>，即实现了Runnbale又实现了Futrue<V>这两个接口，    * 另外它还可以包装Runnable(实际上会转换为Callable)和Callable    * <V>，所以一般来讲是一个符合体了，它可以通过Thread包装来直接执行，也可以提交给ExecuteService来执行    * ，并且还可以通过v get()返回执行结果，在线程体没有执行完成的时候，主线程一直阻塞等待，执行完则直接返回结果。    */   public static void testFutureTask(){    ExecutorService executorService = Executors.newCachedThreadPool();    FutureTask<Integer> futureTask = new FutureTask<Integer>(new Task2());    executorService.submit(futureTask);    try {      System.out.println(futureTask.get());    } catch (InterruptedException e) {      // TODO Auto-generated catch block      e.printStackTrace();    } catch (ExecutionException e) {      // TODO Auto-generated catch block      e.printStackTrace();    }    executorService.shutdown();  }   /**    * FutureTask则是一个RunnableFuture<V>，即实现了Runnbale又实现了Futrue<V>这两个接口，    * 另外它还可以包装Runnable(实际上会转换为Callable)和Callable    * <V>，所以一般来讲是一个符合体了，它可以通过Thread包装来直接执行，也可以提交给ExecuteService来执行    * ，并且还可以通过v get()返回执行结果，在线程体没有执行完成的时候，主线程一直阻塞等待，执行完则直接返回结果。    */   public static void testFutureTask2(){    ExecutorService executorService = Executors.newCachedThreadPool();    FutureTask<Integer> futureTask = new FutureTask<Integer>(new Runnable() {      @Override      public void run() {        // TODO Auto-generated method stub        System.out.println("testFutureTask2 run");      }    },fibc(30));    executorService.submit(futureTask);    try {      System.out.println(futureTask.get());    } catch (InterruptedException e) {      // TODO Auto-generated catch block      e.printStackTrace();    } catch (ExecutionException e) {      // TODO Auto-generated catch block      e.printStackTrace();    }    executorService.shutdown();  }  public static void main(String[] args) {    testCallable();  }  /**    * 效率低下的斐波那契数列, 耗时的操作    *    * @param num    * @return    */   static int fibc(int num) {     if (num == 0) {       return 0;     }     if (num == 1) {       return 1;     }     return fibc(num - 1) + fibc(num - 2);   } }