The overall content of the Android Handler mechanism series is as follows:

The main contents of this article are as follows:

I. overview

Callable

Callable.java source address

(i) Runnable

When it comes to Callable, you can't ignore java.lang.Runnable, which is an interface. It only declares a run() method. Since the return value of the run() method is void, it can't return any results after the task is completed.

public  interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

(ii) Callable

/**
 * A task that returns a result and may throw an exception.
 * Implementors define a single method with no arguments called
 * {@code call}.
 *
 * <p>The {@code Callable} interface is similar to {@link
 * java.lang.Runnable}, in that both are designed for classes whose
 * instances are potentially executed by another thread.  A
 * {@code Runnable}, however, does not return a result and cannot
 * throw a checked exception.
 *
 * <p>The {@link Executors} class contains utility methods to
 * convert from other common forms to {@code Callable} classes.
 *
 * @see Executor
 * @since 1.5
 * @author Doug Lea
 * @param <V> the result type of method {@code call}
 */
@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
     //
    V call() throws Exception;
}

(3) Class annotations for Callable

In order to better understand Callable, we should start with class annotations, which are translated as follows:

(4) The difference between Runnable and Callable:

Three, Future

Future.java source address

(1) Future Class Explanation

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

Five methods are declared in the Future interface. The following are the roles of each method in turn:

To sum up, Future provides three functions:

(2) Future class annotations

• Future It can represent the result of asynchronous computation. Future Provide a method to check whether the calculation has been completed, and a method to retrieve the results. get()The method can obtain the result of calculation, which may cause blockage. If blockage occurs, it will block until the end of calculation. cancel()Method can cancel execution. There are also ways to determine whether a task has been completed or cancelled successfully. If the task has been completed, it can not be cancelled. If you want to use it Future And, hopefully, it's irrevocable and not concerned about the results of implementation, you can declare that Future The generic type of the underlying task, and the return value of the underlying task is null.
• Use example

   class App {
       ExecutorService executor = ...
      ArchiveSearcher searcher = ...

        void showSearch(final String target)
                throws InterruptedException {
            Future<String> future
                    = executor.submit(new Callable<String>() {
                public String call() {
                    return searcher.search(target);
                }
            });
            displayOtherThings(); // do other things while searching
            try {
                displayText(future.get()); // use future
            } catch (ExecutionException ex) {
                cleanup();
                return;
            }
        }
   }

FutureTask is the specific implementation class of Future, and also implements Runnable. So FutureTask can be executed by Executor. For example, Executor's submit method can be replaced by the following

FutureTask<String> future =
  new FutureTask<>(new Callable<String>() {
    public String call() {
      return searcher.search(target);
  }});
executor.execute(future);

Memory consistency effect: If you want to call the Future.get() method on another thread, you should perform its own operations before calling the method.

(3) Boolean cancel (boolean mayInterrupt If Running) method annotation

Translated as follows:

As mentioned above, Future is only an interface, so it can't be used directly to create objects. FutureTask is recommended in the comments, so let's take a look at FutureTask.

IV. FutureTask

FutureTask.java source address
Let's first look at FutureTask's implementation:

(1) Runnable Future

We know by code

public class FutureTask<V> implements RunnableFuture<V>

Explain that the FutureTask class implements the RunnableFuture interface. Let's take a look at the RunnableFuture interface.

RunnableFuture.java source address

/**
 * A {@link Future} that is {@link Runnable}. Successful execution of
 * the {@code run} method causes completion of the {@code Future}
 * and allows access to its results.
 * @see FutureTask
 * @see Executor
 * @since 1.6
 * @author Doug Lea
 * @param <V> The result type returned by this Future's {@code get} method
 */
public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

(2) Class annotations of FutureTask

/**
 * A cancellable asynchronous computation.  This class provides a base
 * implementation of {@link Future}, with methods to start and cancel
 * a computation, query to see if the computation is complete, and
 * retrieve the result of the computation.  The result can only be
 * retrieved when the computation has completed; the {@code get}
 * methods will block if the computation has not yet completed.  Once
 * the computation has completed, the computation cannot be restarted
 * or cancelled (unless the computation is invoked using
 * {@link #runAndReset}).
 *
 * <p>A {@code FutureTask} can be used to wrap a {@link Callable} or
 * {@link Runnable} object.  Because {@code FutureTask} implements
 * {@code Runnable}, a {@code FutureTask} can be submitted to an
 * {@link Executor} for execution.
 *
 * <p>In addition to serving as a standalone class, this class provides
 * {@code protected} functionality that may be useful when creating
 * customized task classes.
 *
 * @since 1.5
 * @author Doug Lea
 * @param <V> The result type returned by this FutureTask's {@code get} methods
 */

In order to better understand the author's design, first look at class annotations, translated as follows:

(3) Structure of FutureTask

The structure is as follows

FutureTask Structural Diagram. png

The relationship of succession is as follows:

Inheritance. png

(4) Static final class WaitNode

    /**
     * Simple linked list nodes to record waiting threads in a Treiber
     * stack.  See other classes such as Phaser and SynchronousQueue
     * for more detailed explanation.
     */
    static final class WaitNode {
        volatile Thread thread;
        volatile WaitNode next;
        WaitNode() { thread = Thread.currentThread(); }
    }

First translate the notes.

The structure is as follows

WaitNode.png

Let's look at constructors and member variables

(5) Status of FutureTask

FutureTask has seven states, coded as follows:

    /*
     * Revision notes: This differs from previous versions of this
     * class that relied on AbstractQueuedSynchronizer, mainly to
     * avoid surprising users about retaining interrupt status during
     * cancellation races. Sync control in the current design relies
     * on a "state" field updated via CAS to track completion, along
     * with a simple Treiber stack to hold waiting threads.
     *
     * Style note: As usual, we bypass overhead of using
     * AtomicXFieldUpdaters and instead directly use Unsafe intrinsics.
     */

    /**
     * The run state of this task, initially NEW.  The run state
     * transitions to a terminal state only in methods set,
     * setException, and cancel.  During completion, state may take on
     * transient values of COMPLETING (while outcome is being set) or
     * INTERRUPTING (only while interrupting the runner to satisfy a
     * cancel(true)). Transitions from these intermediate to final
     * states use cheaper ordered/lazy writes because values are unique
     * and cannot be further modified.
     *
     * Possible state transitions:
     * NEW -> COMPLETING -> NORMAL
     * NEW -> COMPLETING -> EXCEPTIONAL
     * NEW -> CANCELLED
     * NEW -> INTERRUPTING -> INTERRUPTED
     */
    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;

The old rule first translates the annotations. We can see that there are two parts of the annotations. We translate them in turn as follows:

Simply put, FutureTask uses state to represent task status, and state changes are guaranteed atomicity by CAS operations.

I don't feel very good about the translation. Explain it in vernacular.

To sum up, the state change process of FutureTask is as follows:

So let's simply explain a few states.

(6) Member variables of FutureTask

    /** The underlying callable; nulled out after running */
    private Callable<V> callable;
    /** The result to return or exception to throw from get() */
    private Object outcome; // non-volatile, protected by state reads/writes
    /** The thread running the callable; CASed during run() */
    private volatile Thread runner;
    /** Treiber stack of waiting threads */
    private volatile WaitNode waiters;

(7) The Constructive Function of FutureTask

FutureTask has two constructors
They are FutureTask (Callable < V > Callable) and FutureTask(Runnable runnable, V result), so let's analyze them in turn.

1. Constructor FutureTask (Callable < V > Callable)

    /**
     * Creates a {@code FutureTask} that will, upon running, execute the
     * given {@code Callable}.
     *
     * @param  callable the callable task
     * @throws NullPointerException if the callable is null
     */
    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

The old rule first translates the notes:

Looking at the code, we know:

So to sum up, construct a FutureTask by passing in Callable.

2. Constructor FutureTask(Runnable runnable, V result)

    /**
     * Creates a {@code FutureTask} that will, upon running, execute the
     * given {@code Runnable}, and arrange that {@code get} will return the
     * given result on successful completion.
     *
     * @param runnable the runnable task
     * @param result the result to return on successful completion. If
     * you don't need a particular result, consider using
     * constructions of the form:
     * {@code Future<?> f = new FutureTask<Void>(runnable, null)}
     * @throws NullPointerException if the runnable is null
     */
    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }

The old rule first translates the notes:

Looking at the code, we know:

So to conclude, construct a task by passing in Runnable

Incidentally, here's the internal implementation of Executors.callable(runnable, result) method

2.1,Executors.callable(Runnable, T)

    /**
     * Returns a {@link Callable} object that, when
     * called, runs the given task and returns the given result.  This
     * can be useful when applying methods requiring a
     * {@code Callable} to an otherwise resultless action.
     * @param task the task to run
     * @param result the result to return
     * @param <T> the type of the result
     * @return a callable object
     * @throws NullPointerException if task null
     */
    public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }

The inside of the method is very simple. It's a new Runnable Adapter and returns. Let's take a look at the Runnable Adapter adapter.

    /**
     * A callable that runs given task and returns given result.
     */
    private static final class RunnableAdapter<T> implements Callable<T> {
        private final Runnable task;
        private final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
    }

From the above code, we know that:

This is actually a Runnable object disguised as a Callable object, which is an adapter object.

3. Summary of constructors

By analyzing the above two constructors, we know that whether we use the first constructor or the second constructor, the result is to initialize and assign the local variable callable, so FutureTask ultimately performs Callable-type tasks. Then set the state to NEW.

(8) Several Core Methods of FutureTask

FutureTask has several core approaches:

Let's look at it in turn.

1. run() method

    /**
     * Determine whether the state of the task is initialized?
     * Determine whether the thread object runner that executes the task is null or not, assign the current thread of execution to the runner attribute if it is empty
     *  Instead of empty instructions, there should be threads ready to perform this task
     */
    public void run() {
        if (state != NEW ||
            !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
            return;
        try {
           // When the task state is NEW and the callable is not empty, the task is executed
           // If you think it's cancel ed, callable will be emptied
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                
                V result;  // Variables of outcomes
                
                boolean ran;  // Executed variables
                try {
                    // Execute tasks and return results
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    // Execution exception
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    //Set the results when the task is finished
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            // Clear the execution thread of the task 
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                //Judging the state of threads
                handlePossibleCancellationInterrupt(s);
        }
    }

From the above code and comments, we know that the flow inside the run method is as follows:

1.1. Unsafe class

Java does not have direct access to the underlying operating system, but through local methods. Unsafe provides hardware-level atomic access, mainly providing the following functions:

The main method is compare AndSwap ()

1.1.1 UNSAFE. comparison AndSwapObject (this, runner Offset, null, Thread. current Thread ()) method

What does the line UNSAFE. compare AndSwapObject (this, RUNNER, null, Thread. current Thread ()) mean?

Translation into vernacular is:

The concept mentioned above is RUNNER. What is this RUNNER?
We found it in the source code

    // Unsafe mechanics
    private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();
    private static final long STATE;
    private static final long RUNNER;
    private static final long WAITERS;
    static {
        try {
            STATE = U.objectFieldOffset
                (FutureTask.class.getDeclaredField("state"));
            RUNNER = U.objectFieldOffset
                (FutureTask.class.getDeclaredField("runner"));
            WAITERS = U.objectFieldOffset
                (FutureTask.class.getDeclaredField("waiters"));
        } catch (ReflectiveOperationException e) {
            throw new Error(e);
        }

        // Reduce the risk of rare disastrous classloading in first call to
        // LockSupport.park: https://bugs.openjdk.java.net/browse/JDK-8074773
        Class<?> ensureLoaded = LockSupport.class;
    }

It corresponds to the member variables of runner, that is, if the state is not NEW or runner is not null, the run method returns directly.

In this run method, setException(Throwable) and set(V) methods are invoked, so let's look at them in detail.

1.2. SetException (Throwable) Method

    /**
     * Causes this future to report an {@link ExecutionException}
     * with the given throwable as its cause, unless this future has
     * already been set or has been cancelled.
     *
     * <p>This method is invoked internally by the {@link #run} method
     * upon failure of the computation.
     *
     * @param t the cause of failure
     */
    protected void setException(Throwable t) {
         // State state NEW - > COMPLETING
        if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
            outcome = t;
             // // COMPLETING - > EXCEPTIONAL reaches stable state
            U.putOrderedInt(this, STATE, EXCEPTIONAL); // final state
            // Some closures
            finishCompletion();
        }
    }

Simply translate the notes of the method:

So to sum up, when there are exceptions in the process of task execution, how to deal with exceptions

1.3. set (V) method

The main method is to perform the assignment operation of the result.

    /**
     * Sets the result of this future to the given value unless
     * this future has already been set or has been cancelled.
     *
     * <p>This method is invoked internally by the {@link #run} method
     * upon successful completion of the computation.
     *
     * @param v the value
     */
    protected void set(V v) {
        // State state NEW - > COMPLETING
        if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
            outcome = v;
            // COMPLETING - > NORMAL reaches stable state
            U.putOrderedInt(this, STATE, NORMAL); // final state
            // Some closures
            finishCompletion();
        }
    }

From the above we know that the internal process of this method is as follows:

PS: The putOrderedInt method of UNSAFE is used here, which is actually the method used inside the LazySet of atomic weight. Why use this method? First, LazySet is cheaper than Volatile-Write because it does not have an expensive Store/Load barrier. Second, subsequent threads will not see the state change from COMPLETING to NORMAL in time, but that doesn't matter, and NORMAL is the final state of state and will not change any more.

The finishCompletion() method is called in this method, so let's take a look at this method.

1.4. finishCompletion() Method

This method is:

The code is as follows:

    /**
     * Removes and signals all waiting threads, invokes done(), and
     * nulls out callable.
     */
    private void finishCompletion() {
        // assert state > COMPLETING;
        // Traversing Waiting Nodes
        for (WaitNode q; (q = waiters) != null;) {
            if (U.compareAndSwapObject(this, WAITERS, q, null)) {
                for (;;) {
                    Thread t = q.thread;
                    if (t != null) {
                        q.thread = null;
                        // Wake up waiting threads
                        LockSupport.unpark(t);
                    }
                    WaitNode next = q.next;
                    if (next == null)
                        break;
                    q.next = null; // unlink to help gc
                    q = next;
                }
                break;
            }
        }
        // Here you can customize what you want to do when the implementation task is completed (override the done() method in the subclass)
        done();
        // Clear callable
        callable = null;        // to reduce footprint
    }

·

1.4.1, Introduction to LockSupport

First of all, I will talk about LockSupport. Many novices are not very familiar with this thing. Let me talk about it briefly, but I will not elaborate on it here.

Operating Object of \\\\\\\\\\\
LockSupport calls Unsafe's natvie code:

public native void unpark(Thread jthread); 
public native void park(boolean isAbsolute, long time); 

These two function declarations clearly state the object of operation: the park function blocks the current Thread, while the unPark function wakes up another Thread.

Compared with wait/notify mechanism of Object class, park/unpark has two advantages:

#\\\\\\\\\\\\
In the above file, blocking and wake-up are used to compare with wait/notify. In fact, the core design principle of park/unpark is "license". Park is waiting for a license. Unpark provides a "license" for a thread. If a thread A calls park, thread A will block the park operation unless another thread unpark(A) gives A a license.

1.5. HandlePossibleCancellation Interrupt (int) method

    /**
     * Ensures that any interrupt from a possible cancel(true) is only
     * delivered to a task while in run or runAndReset.
     */
    private void handlePossibleCancellationInterrupt(int s) {
        // It is possible for our interrupter to stall before getting a
        // chance to interrupt us.  Let's spin-wait patiently.
        // If the interrupt is currently in progress, wait for the interrupt to complete
        if (s == INTERRUPTING)
            while (state == INTERRUPTING)
                Thread.yield(); // wait out pending interrupt

        // assert state == INTERRUPTED;

        // We want to clear any interrupt we may have received from
        // cancel(true).  However, it is permissible to use interrupts
        // as an independent mechanism for a task to communicate with
        // its caller, and there is no way to clear only the
        // cancellation interrupt.
        //
        // Thread.interrupted();
    }

Let's start with the notes:

Looking at the code, we know that his main idea is that if other threads are terminating the task, the threads running the task temporarily give up CPU time until state= INTERRUPTED.

So its function is to uuuuuuuuuuuu

2. get() and get(long, TimeUnit) methods

Tasks are executed by threads provided by the thread pool, and then the main thread blocks until the task thread wakes them up. Let's see what get() does.

2.1 get() method

The code is as follows:

    /**
     * @throws CancellationException {@inheritDoc}
     */
    public V get() throws InterruptedException, ExecutionException {
        int s = state;
        // A state less than COMPLETING indicates that the task is still executing and has not been cancelled.
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }

We know by code

There are two methods involved: awaitDone(boolean,long) method and report(int) method. Let's look at them in turn.

2.1.1 awaitDone (boolean, long) method

This method mainly waits for the task to finish, and stops if the task cancels or times out.
The code is as follows:

    /**
     * Awaits completion or aborts on interrupt or timeout.
     *
     * @param timed true if use timed waits
     * @param nanos time to wait, if timed
     * @return state upon completion or at timeout
     */
    private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
        // The code below is very delicate, to achieve these goals:
        // - call nanoTime exactly once for each call to park
        // - if nanos <= 0L, return promptly without allocation or nanoTime
        // - if nanos == Long.MIN_VALUE, don't underflow
        // - if nanos == Long.MAX_VALUE, and nanoTime is non-monotonic
        //   and we suffer a spurious wakeup, we will do no worse than
        //   to park-spin for a while
        // Starting time
        long startTime = 0L;    // Special value 0L means not yet parked
        // Nodes currently waiting for threads
        WaitNode q = null;
         // Is the node in the waiting list?
        boolean queued = false;
        // Thread Blocking Waiting Through Dead Loop
        for (;;) {
            int s = state;
            if (s > COMPLETING) {
                 // Tasks may have been completed or cancelled
                if (q != null)
                    q.thread = null;
                return s;
            }
            else if (s == COMPLETING)
                // We may have already promised (via isDone) that we are done
                // so never return empty-handed or throw InterruptedException
                // Task threads may be blocked to give up cpu
                Thread.yield();
            else if (Thread.interrupted()) {
                // Thread interrupts remove waiting threads and throw exceptions
                removeWaiter(q);
                throw new InterruptedException();
            }
            else if (q == null) {
                // If the waiting node is empty, initialize the new node and associate the current thread
                if (timed && nanos <= 0L)
                   // If you need to wait, and the waiting time is less than 0 to indicate immediate, return directly
                    return s;
                // If you don't need to wait, or if you need to wait, but the waiting time is more than 0.
                q = new WaitNode();
            }
            else if (!queued)
                // Wait for threads to join the queue, because queued=true if the queue succeeds
                queued = U.compareAndSwapObject(this, WAITERS,
                                                q.next = waiters, q);
            else if (timed) {
                //If there is a timeout setting
                final long parkNanos;
                if (startTime == 0L) { // first time
                    startTime = System.nanoTime();
                    if (startTime == 0L)
                        startTime = 1L;
                    parkNanos = nanos;
                } else {
                    long elapsed = System.nanoTime() - startTime;
                    if (elapsed >= nanos) {
                        // If it has timed out, the waiting node is removed
                        removeWaiter(q);
                        return state;
                    }
                    parkNanos = nanos - elapsed;
                }
                // nanoTime may be slow; recheck before parking
                if (state < COMPLETING)
                    // The task is still in progress and hasn't been cancelled, so keep waiting.
                    LockSupport.parkNanos(this, parkNanos);
            }
            else
                LockSupport.park(this);
        }
    }

Two participants:

The logic in the for dead loop is as follows:

So sum up:

This method calls the removeWaiter(WaitNode) method, so let's first see how this removeWaiter(WaitNode) is implemented.

2.1.2 removeWaiter(WaitNode)

    /**
     * Tries to unlink a timed-out or interrupted wait node to avoid
     * accumulating garbage.  Internal nodes are simply unspliced
     * without CAS since it is harmless if they are traversed anyway
     * by releasers.  To avoid effects of unsplicing from already
     * removed nodes, the list is retraversed in case of an apparent
     * race.  This is slow when there are a lot of nodes, but we don't
     * expect lists to be long enough to outweigh higher-overhead
     * schemes.
     */
    private void removeWaiter(WaitNode node) {
        if (node != null) {
            // Empty the node's thread field
            node.thread = null;
            /**
             * The following procedure removes the node from the waiting queue, based on thread as null
             * If there is competition in the process, try again
             */
            retry:
            for (;;) {          // restart on removeWaiter race
                for (WaitNode pred = null, q = waiters, s; q != null; q = s) {
                    s = q.next;
                    if (q.thread != null)
                        pred = q;
                    else if (pred != null) {
                        pred.next = s;
                        if (pred.thread == null) // check for race
                            continue retry;
                    }
                    else if (!U.compareAndSwapObject(this, WAITERS, q, s))
                        continue retry;
                }
                break;
            }
        }
    }

First, let's look at the annotations for classes

This method is mainly to remove thread nodes from the waiting queue.

2.1.2 report (int) method

    /**
     * Returns result or throws exception for completed task.
     *
     * @param s completed state value
     */
    @SuppressWarnings("unchecked")
    private V report(int s) throws ExecutionException {
        Object x = outcome;
         // If the task is completed normally, the result of the task execution is returned.
        if (s == NORMAL)
            return (V)x;

        // If the task is cancelled, an exception is thrown
        if (s >= CANCELLED)
            throw new CancellationException();
        
        // Other states throw execution exceptions ExecutionException 
        throw new ExecutionException((Throwable)x);
    }

report.png

2.2 get(long, TimeUnit) method

Wait for the result after calculating the time given for completion at most

    /**
     * @throws CancellationException {@inheritDoc}
     */
    public V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
        if (unit == null)
            throw new NullPointerException();
        int s = state;
        if (s <= COMPLETING &&
            (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
            throw new TimeoutException();
        return report(s);
    }

The source code of the parametric get method is very concise. First, the parameters are checked, then the timeout is judged according to the state state. If the timeout is abnormal, the report is called to get the final result.
When s <= COMPLETING, it indicates that the task is still executing and has not been cancelled. If it is true, go to the awaitDone method. The awaitDone method has been explained above, but it's just explained here.

3. cancel(boolean) method

Only tasks that have not yet been executed can be cancelled (tasks with NEW status)

    public boolean cancel(boolean mayInterruptIfRunning) {
        // If the task state is not initialized, cancel the task
         //If the task has been executed and may be completed, but the state change has not yet been modified, that is, the set() method in the run() method has not yet been invoked.
         //   Continue to determine whether the current state of the task is NEW, because at this point the thread executing the task may be processed again, and the task status may have changed.
        if (!(state == NEW &&
              U.compareAndSwapInt(this, STATE, NEW,
                  mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
                return false;

        // If the task state is still NEW, that is, the executing thread does not change the state of the task.
        // Let the execution thread interrupt (the execution thread may change the state of the task in this process)
        try {    // in case call to interrupt throws exception
            if (mayInterruptIfRunning) {
                try {
                    Thread t = runner;
                    if (t != null)
                        t.interrupt();
                } finally { // final state
                    // Set task status to interrupt
                    U.putOrderedInt(this, STATE, INTERRUPTED);
                }
            }
        } finally {
            // Processing the results of task completion
            finishCompletion();
        }
        return true;
    }

From the above code, we know that this cancellation does not necessarily work.

The above code logic is as follows:

Therefore, cancel() method changes the status of futureTask. If the incoming is false and the business logic has started to execute, the current task will not be terminated, but will continue to execute until the exception is known or the execution is completed. If true is passed in, the interrupt() method of the current thread is called and the interrupt flag bit is set to true.

4. runAndReset() Method

Tasks can be performed multiple times

    /**
     * Executes the computation without setting its result, and then
     * resets this future to initial state, failing to do so if the
     * computation encounters an exception or is cancelled.  This is
     * designed for use with tasks that intrinsically execute more
     * than once.
     *
     * @return {@code true} if successfully run and reset
     */
    protected boolean runAndReset() {
        if (state != NEW ||
            !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
            return false;
        boolean ran = false;
        int s = state;
        try {
            Callable<V> c = callable;
            if (c != null && s == NEW) {
                try {
                    c.call(); // don't set result
                    ran = true;
                } catch (Throwable ex) {
                    setException(ex);
                }
            }
        } 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
            s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
        return ran && s == NEW;
    }

Let's start with the notes:

We can compare runAndReset and run methods. In fact, they are not very different. There are two main differences.

Let's look at the handlePossibleCancellation Interrupt (int) method

Five, summary