Future掌控未来之Callable是如何管理返回值和异常的【源码向】

public class FutureTest {
    public static void main(String[] args) {
        //1. 创建FutureTask并传入callable实例
        Future<String> stringFutureTask = new FutureTask<>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(3000);
                return "FutureTask";
            }
        });
        //2. 把实例传递给Thread并启动
        new Thread(stringFutureTask).start();

        String s = "";
        try {
            //3. 阻塞获取结果
            s = stringFutureTask.get();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.printf(s);
    }
}

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

@Override
public void run() {
    //把当前线程赋值给FutureTask.runner 实例
    runner = Thread.currentThread();
    try {
      // 赋值变量
      Callable<V> c = callable;
      //启动状态为NEW
      if (c != null && state == NEW) {
        // 定义结果变量
        V result;
        boolean ran;
        try {
          //1. 这里调用 callable.call() 方法，也就是第一步传入的callable. 并返回结果
          result = c.call();
          ran = true;
        } catch (Throwable ex) {
          //如果抛出异常，
          result = null;
          ran = false;
          //改变线程状态为 COMPLETING
          if (STATE.compareAndSet(this, NEW, COMPLETING)) {
             //2. 把异常赋给 outcome 变量
              outcome = ex;
              // 改变线程状态为 EXCEPTIONAL
              STATE.setRelease(this, EXCEPTIONAL);
         }
        }
        if (ran) {
          //设置结果并通知所有等待的线程
          set(result);
        }
      }
    } finally {
      ...
    }
}

protected void set(V v) {
    // 改变线程状态为 EXCEPTIONAL
    if (STATE.compareAndSet(this, NEW, COMPLETING)) {
      //3. 把结果赋给 outcome 变量
      outcome = v;
      // 改变线程状态为 NORMAL
      STATE.setRelease(this, NORMAL);
   // 4. 遍历阻塞等待的获取锁的线程，通知他们锁已释放
      for (WaitNode q; (q = waiters) != null;) {
        if (WAITERS.weakCompareAndSet(this, q, null)) {
          for (;;) {
            Thread t = q.thread;
            if (t != null) {
              q.thread = null;
              // 通知锁已释放
              LockSupport.unpark(t);
            }
            FutureTask.WaitNode next = q.next;
            if (next == null) {
              break;
            }
            q.next = null;
            q = next;
          }
          break;
        }
      }
      callable = null;
    }
}

public V get() throws Exception {
    int s = state;
    if (s <= COMPLETING) {
     // 1. 如果线程还在执行，就就到waiters 链表里面阻塞等待结果。
     s = awaitDone();
    }
   // 获取结果
    if (s == NORMAL) {
       // 2. 如果正常就返回正常的结果 outcome
       return (V)outcome;
    }
    // 3. 如果异常就直接抛出 outcome
    throw new Exception((Throwable)outcome);
}

// 这个方法的意思就是，如果线程还在执行，就到waiters 链表里面等待，
// 一直到被 LockSupport.unpark() 唤醒
private int awaitDone() {
    WaitNode q = null;
    boolean queued = false;
    for (;;) {
        int s = state;
        if (s > COMPLETING) {
          return s;
        } else if (s == COMPLETING) {
          Thread.yield();
        } else if (q == null) {
          q = new WaitNode();
        }  if (!queued) {
          queued = WAITERS.weakCompareAndSet(this, q.next = waiters, q);
        } else {
          LockSupport.park(this);
        }
    }
}