解析Java異步之call future

public interface Callable<V> {
    V call() throws Exception;
}


public interface Runnable {
    public abstract void run();
}

public interface Executor {
    void execute(Runnable command);
}

public interface ExecutorService extends Executor {

    void shutdown();                // 現有任務完成後停止線程池
 
    List<Runnable> shutdownNow();   // 立即停止線程池

    boolean isShutdown();           // 判斷是否已停止

    boolean isTerminated();

    <T> Future<T> submit(Callable<T> task);        // 提交Callale任務

    <T> Future<T> submit(Runnable task, T result);

    Future<?> submit(Runnable task);

    // 針對Callable集合的invokeAll()等方法
}

// 1.第一個重載方法，參數為Callable
public <T> Future<T> submit(Callable<T> task) {
  if (task == null) throw new NullPointerException();
  RunnableFuture<T> ftask = newTaskFor(task);
  // return new FutureTask<T>(callable);
  execute(ftask);
  return ftask;
}

// 2.第二個重載方法，參數為Runnable
public Future<?> submit(Runnable task) {
  if (task == null) throw new NullPointerException();
  RunnableFuture<Void> ftask = newTaskFor(task, null);
  // return new FutureTask<T>(task, null);
  execute(ftask);
  return ftask;
}

// 3.第三個重載方法，參數為Runnable + 返回對象
public <T> Future<T> submit(Runnable task, T result) {
  if (task == null) throw new NullPointerException();
  RunnableFuture<T> ftask = newTaskFor(task, result);
  // return new FutureTask<T>(task, result);
  execute(ftask);
  return ftask;
}

public FutureTask(Callable<V> callable) {
  this.callable = callable;
  this.state = NEW;
}

public FutureTask(Runnable runnable, V result) {
  this.callable = Executors.callable(runnable, result); // 通過適配器將runnable在call()中執行並返回result
  this.state = NEW;
}

static final class RunnableAdapter<T> implements Callable<T> {
  final Runnable task;
  final T result;                // 返回的結果；顯然：需要在run()中賦值

  RunnableAdapter(Runnable task, T result) {
    this.task = task;
    this.result = result;
  }
  public T call() {
    task.run();
    return result;
  }
}

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 interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation unless it has been cancelled.
     */
    void run();
}

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;

public class FutureTask<V> implements RunnableFuture<V> {
    
    private Callable<V> callable;         // target，待執行的任務
    
    /** 保存執行結果或異常，在get()方法中返回/拋出 */
    private Object outcome; // 非volatile，通過CAS保證線程安全
    
    
    public void run() {
        ......
        Callable<V> c = callable;
        if (c != null && state == NEW) {
            V result;
            boolean ran;
            try {
                result = c.call();            // 調用call()執行用戶任務並獲取結果
                ran = true;                   // 執行完成，ran置為true
            } catch (Throwable ex) {          // 調用call()出現異常，而run()方法繼續執行
                 result = null;
                 ran = false;
                 setException(ex);            
                 // setException(Throwable t): compareAndSwapInt(NEW, COMPLETING);  outcome = t;      
            }
            if (ran)
                set(result);                  
            	// set(V v): compareAndSwapInt(NEW, COMPLETING);  outcome = v;
        }
    }
    
    
    public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);         // 加入隊列等待COMPLETING完成，可響應超時、中斷
        return report(s);
    }

    public V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
        // 超時等待
    }
    
    private V report(int s) throws ExecutionException {
        Object x = outcome;
        if (s == NORMAL)                              // 將outcome作為執行結果返回
            return (V)x;
        if (s >= CANCELLED)
            throw new CancellationException();
        throw new ExecutionException((Throwable)x);   // 將outcome作為捕獲的返回
    }
}

class MyTask implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("子線程開始計算...");
        for (int i=0;i<3;++i){
            Thread.sleep(1000);
            System.out.println("子線程計算中，用時 "+(i+1)+" 秒");
        }
        System.out.println("子線程計算完成，返回：100");
        return 100;
    }
}

ExecutorService executor = Executors.newCachedThreadPool();
MyTask task = new MyTask();

System.out.println("主線程啟動線程池");
Future<Integer> future = executor.submit(task);
System.out.println("主線程得到返回結果："+future.get());
executor.shutdown();

System.out.println("主線程啟動線程池");
FutureTask<Integer> futureTask = new FutureTask<>(task);
executor.submit(futureTask);                                 // 作為Ruunable傳入submit()中
System.out.println("主線程得到返回結果："+futureTask.get());    // 作為Future獲取結果
executor.shutdown();