Shulou(Shulou.com)05/31 Report--

This article Xiaobian introduces in detail for you "Java asynchronous task computing FutureTask source code analysis", the content is detailed, the steps are clear, and the details are handled properly. I hope this "Java asynchronous task computing FutureTask source code analysis" article can help you solve your doubts.

Know what FutureTask is?

FutureTask is a cancelable asynchronous calculation.

FutureTask provides a basic implementation of Future, you can call methods to start and cancel a calculation, you can query whether the calculation is complete, and get the results.

FutureTask can only get the calculation result after the calculation is completed, and once the calculation is completed, it cannot be restarted or cancelled unless the runAndReset method is called.

FutureTask implements not only the Future interface, but also the Runnable interface, so FutureTask can be executed either by Executor of the thread pool or directly using an asynchronous thread call (futureTask.run ()).

How is FutureTask implemented?

First, let's look at the inheritance structure of the FutureTask class, as shown in the following figure, which implements the RunnableFuture interface, while RunnableFuture inherits from Future and the functional interface Runnable, so FutureTask is essentially a runnable Future.

The Future API specifies some functions that must be implemented by asynchronous computing classes. The source codes are as follows:

Package java.util.concurrent;public interface Future {/ * attempted to cancel the execution of the task and returned the cancellation result. * Parameter mayInterruptIfRunning: whether to interrupt the thread. * / boolean cancel (boolean mayInterruptIfRunning); / * determine whether the task is cancelled (returned to true before the normal end) * / boolean isCancelled (); / * * determine whether the current task has completed execution, including normal execution, abnormal execution, or task cancellation. * / boolean isDone (); / * get the execution result of the task, which will block before the task ends. * / V get () throws InterruptedException, ExecutionException; / * attempts to obtain the execution result within a specified time. If timeout occurs, a timeout exception TimeoutException * / V get (long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;} is thrown.

We are all familiar with the Runnable interface, which is a functional interface, and we often use it to create a thread.

Package java.lang;?@FunctionalInterfacepublic interface Runnable {? public abstract void run ();}

FutureTask is a task to be executed, which contains the specific implementation of the above APIs. FutureTask defines the status state of the task and some state constants. Its internal core is a Callable callable. We can input callable or runnable through the constructor, and eventually it will be internally converted to callable, because we need to obtain the execution results of asynchronous tasks, and only threads created through Callable will return results.

We can judge the return result of isCancelled () and isDone () in Future by the state at this time.

The following is the FutureTask source code with core source code analysis notes

Package java.util.concurrent;import java.util.concurrent.locks.LockSupport;public class FutureTask implements RunnableFuture {/ * running status of the task * / private volatile int state; private static final int NEW = 0; / / New private static final int COMPLETING = 1; / / completed private static final int NORMAL = 2; / / normal private static final int EXCEPTIONAL = 3 / / exception private static final int CANCELLED = 4; / / cancel private static final int INTERRUPTING = 5; / / interrupt private static final int INTERRUPTED = 6; / / interrupted private Callable callable; / * return result * / private Object outcome; private volatile Thread runner; private volatile WaitNode waiters;. Public FutureTask (Callable callable) {if (callable = = null) throw new NullPointerException (); this.callable = callable; this.state = NEW;} public FutureTask (Runnable runnable, V result) {this.callable = Executors.callable (runnable, result); this.state = NEW;} public boolean isCancelled () {return state > = CANCELLED } public boolean isDone () {return state! = NEW;} / * * cancel task implementation * if cancel (true) is called before the task is started, the task will never be executed. * if the task has been started, the parameter mayInterruptIfRunning determines whether the task should interrupt the thread executing the task in an attempt to interrupt the task. * if the task has been cancelled, completed, or cannot be cancelled for other reasons, the attempt will fail. * / public boolean cancel (boolean mayInterruptIfRunning) {if (! (state = = NEW & & UNSAFE.compareAndSwapInt (this, stateOffset, NEW, mayInterruptIfRunning? INTERRUPTING: CANCELLED)) return false; try {/ / in case call to interrupt throws exception if (mayInterruptIfRunning) {try {Thread t = runner; if (t! = null) t.interrupt () } finally {/ / final state UNSAFE.putOrderedInt (this, stateOffset, INTERRUPTED);} finally {finishCompletion ();} return true;} / * * wait for the result * to obtain the current status to determine whether the execution is completed. And determine whether the time has timed out * if the task is not completed, it blocks waiting for completion, and throws a timeout wait exception if the timeout occurs. * / public V get () throws InterruptedException, ExecutionException {int s = state; if (s)

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.