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

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);//runnable轉(zhuǎn)化為callable 
  this.state = NEW;  // ensure visibility of callable
  }
｝

// 執(zhí)行任務(wù) 實(shí)現(xiàn)Runnable
 FutureTaskJobRunnable taskRun = new FutureTaskJobRunnable();
 // 執(zhí)行任務(wù) 實(shí)現(xiàn)Callable
 FutureTaskJobCallable taskCall = new FutureTaskJobCallable();
 String val = "ok";
 // 線程運(yùn)行成功后把,返回你傳入的val值
 FutureTask<String> futureTaskRun = new FutureTask<String>(taskRun, val);
 // 線程運(yùn)行，返回線程執(zhí)行的結(jié)果
 FutureTask<String> futureTaskCall = new FutureTask<String>(taskCall);
 //聲明線程池
 ExecutorService executor = Executors.newCachedThreadPool();  
 //Future
 Future<String> future = executor.submit(taskCall);
 System.out.println(future.get());
 //FutureTask
 executor.submit(futureTaskCall);
 System.out.println(futureTaskCall.get());
 //FutureTask自定義線程執(zhí)行
 new Thread(futureTaskRun).start();
 System.out.println(futureTaskRun.get());

public class FutureTaskJobCallable implements Callable<String>{
  
 public String call() throws Exception {
  System.out.println("FutureTaskJobCallable已經(jīng)執(zhí)行了哦");
  Thread.sleep(1000);
  return "返回結(jié)果";
 }
}
public class FutureTaskJobRunnable implements Runnable {
 public void run() {
  try {
   Thread.sleep(1000);
  } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  System.out.println("FutureTaskJobRunnable已經(jīng)執(zhí)行了哦");
 }
}

public Future<?> submit(Runnable task) {
  if (task == null) throw new NullPointerException();
  RunnableFuture<Void> ftask = newTaskFor(task, null);
  execute(ftask);
  return ftask;
 }
 public <T> Future<T> submit(Runnable task, T result) {
  if (task == null) throw new NullPointerException();
  RunnableFuture<T> ftask = newTaskFor(task, result);
  execute(ftask);
  return ftask;
 }
 public <T> Future<T> submit(Callable<T> task) {
  if (task == null) throw new NullPointerException();
  RunnableFuture<T> ftask = newTaskFor(task);
  execute(ftask);
  return ftask;
 }
 protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
  return new FutureTask<T>(runnable, value);
 }
 protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
  return new FutureTask<T>(callable);
 }

//你傳入的Runnable與Callable實(shí)現(xiàn)類都會在構(gòu)造函數(shù)中轉(zhuǎn)化為Callable
private Callable<V> callable;
 public void run() {
  if (state != NEW ||
   !UNSAFE.compareAndSwapObject(this, runnerOffset,
           null, Thread.currentThread()))
   return;
  try {
   Callable<V> c = callable;//你傳入的實(shí)現(xiàn)類
   if (c != null && state == NEW) {
    V result;//返回值
    boolean ran;
    try {
     result = c.call();//運(yùn)行后返回結(jié)果
     ran = true;
    } catch (Throwable ex) {
     result = null;
     ran = false;
     setException(ex);
    }
    if (ran)
     set(result);
   }
  } finally {
   // runner must be non-null until state is settled to
   // prevent concurrent calls to run()
   runner = null;
   // state must be re-read after nulling runner to prevent
   // leaked interrupts
   int s = state;
   if (s >= INTERRUPTING)
    handlePossibleCancellationInterrupt(s);
  }
 }