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

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

public static void main(String[] args) {
    Callable<String> callableExample = () -> "This is the results.";
    try {
        String result = callableExample.call();
        System.out.println("Callable 실행 결과: " + result);
    } catch (Exception e) {
        System.out.println("There is a exception.");
    }
}

public class FutureTest {
    public static void main(String[] args) {
        // 1. 비동기로 실행할 Callable 구현체를 매개변수로 넘겨주며 FutureTask를 생성한다.
        Future<String> stringFutureTask = new FutureTask<>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(3000);
                return "FutureTask";
            }
        });
        //2. FutureTask인스턴스를 Thread에 전달하고 실행한다.
        new Thread(stringFutureTask).start();

        String s = "";
        try {
            //3. 비동기 작업이 완료될 때까지 Blocking되어 결과를 기다려 얻는다.
            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;
      // FutureTask의 상태를 시작 상태인 NEW로 설정한다.
      if (c != null && state == NEW) {
        // 결과를 담을 변수를 정의한다.
        V result;
        boolean ran;
        try {
          // 1. 여기서 첫번째 단계에서 전달받은 Callable의 call()을 호출하고 결과를 반환받는다.
          result = c.call();
          ran = true;
        } catch (Throwable ex) {
          //만약 Callable.call 실행 과정에서 예외가 발생했다면，
          result = null;
          ran = false;
          // FutureTask의 스레드 상태를 COMPLETING으로 수정한다.
          if (STATE.compareAndSet(this, NEW, COMPLETING)) {
              // 2. 예외를 FutureTask의 결과 담는 변수인 outcome에 할당한다.
              outcome = ex;
              // FutureTask의 스레드 상태를 EXCEPTIONAL로 변경한다.
              STATE.setRelease(this, EXCEPTIONAL);
         }
        }
        if (ran) {
          // 결과를 설정하고 비동기 결과를 대기 중인 모든 스레드에 알린다.
          set(result);
        }
      }
    } finally {
      ...
    }
}

protected void set(V v) {
    // FutureTask의 스레드 상태를 EXCEPTIONAL로 변경한다.
    if (STATE.compareAndSet(this, NEW, COMPLETING)) {
      //3. 비동기로 실행한 결과를 outcome변수에 할당한다. - 중요
      outcome = v;
      // FutureTask의 스레드 상태를 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. 비동기 Task를 실행중인 스레드가 아직 실행중이라면 대기자 연결 목록으로 이동하여 Blocking 상태에서 결과를 기다린다.
     s = awaitDone();
    }
    // 비동기 처리 결과를 얻는다.
    if (s == NORMAL) {
       // 2. 정상적으로 결과가 반환된 경우 결과가 저장된 outcome을 그대로 반환한다. (이제 Blocking이 풀린다.)
       return (V)outcome;
    }
    // 3. 만약 예외로 던져였을 경우 outcome에 저장된 예외를 직접 풀린다.
    throw new Exception((Throwable)outcome);
}

// 이 메서드는 비동기 Task를 실행중인 스레드가 여전히 실행 중인 경우, 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);
        }
    }
}