Understanding FutureTask: Features, Implementation, and Common Pitfalls

FutureTask works like a proxy agency that triggers, monitors, and records the result, exception, and execution state of an asynchronous task submitted to a thread pool.

Typical usage is shown in the following example, where a FutureTask<String> is created with a lambda that sleeps for three seconds and returns "done", then started in a new thread and its result retrieved via futureTask.get() :

/**
 * @author 认知科技技术团队
 * 微信公众号：认知科技技术团队
 */
public class ThreadPoolConfig {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask
futureTask = new FutureTask(() -> {
            Thread.sleep(1000 * 3);
            return "done";
        });
        new Thread(futureTask).start();
        String result = futureTask.get();
        System.out.println(result);
    }
}

Internally, FutureTask stores the submitted Callable and an initial state:

this.callable = callable;
this.state = NEW;

Key fields include:

/** The underlying callable; nulled out after running */
private Callable
callable;

private volatile int state;

When the thread actually runs, the proxy invokes the callable and marks the task as run:

result = c.call();
ran = true;

The outcome (either the return value or an exception) is stored in:

/** The result to return or exception to throw from get() */
private Object outcome; // non-volatile, protected by state reads/writes

The state is managed via a VarHandle:

private static final VarHandle STATE;

Calling FutureTask#get() (or the timed variant) blocks the calling thread until the task completes; if the task is still running, the thread remains blocked until the state changes and the waiting thread is awakened.

java.util.concurrent.FutureTask#get()
java.util.concurrent.FutureTask#get(long, java.util.concurrent.TimeUnit)

Common pitfalls highlighted include:

Never calling get() may cause loss of exception information because exceptions are stored inside the FutureTask.

Using a non‑timed get() can lead to indefinite blocking, especially when the executor’s default rejection policy (e.g., ThreadPoolExecutor.DiscardPolicy ) prevents task state updates.

In summary, FutureTask serves as a lightweight proxy that records execution results and exceptions while providing a blocking‑and‑wakeup mechanism; however, developers must remember to retrieve results with a timeout or handle possible blocking to avoid hidden errors.