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

This article mainly explains "how to use Callable, Future and FutureTask". Interested friends may wish to have a look at it. The method introduced in this paper is simple, fast and practical. Let's let the editor learn how to use Callable, Future and FutureTask.

There are two ways to create a thread, one is to inherit Thread directly, and the other is to implement the Runnable interface. A drawback of both methods is that the execution result cannot be obtained after the task has been executed.

Since Java 1.5, Callable and Future have been provided, through which the results of task execution can be obtained after the task has been executed.

# CountDownLatch usage

Let's start with java.lang.Runnable, which is an interface in which only one run () method is declared:

Public interface Runnable {public abstract void run ();}

Because the return value of the run () method is of type void, no results can be returned after the task is executed.

Callable is located under the java.util.concurrent package, which is also an interface in which only one method is declared, but this method is called call ():

Public interface Callable {/ * * 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;}

As you can see, this is a generic interface, and the type returned by the call () function is the V type passed in.

So how do you use Callable? Generally used in conjunction with ExecutorService, several overloaded versions of submit methods are declared in the ExecutorService interface

Future submit (Callable task); Future submit (Runnable task, T result); Future submit (Runnable task)

The parameter type in the first submit method is Callable.

For the time being, you only need to know that Callable is generally used in conjunction with ExecutorService, and the specific usage will be described later.

Generally, we use the first submit method and the third submit method, while the second submit method is rarely used.

# Future

Future is to cancel the execution result of a specific Runnable or Callable task, query whether it is completed, and obtain the result. If necessary, the execution result can be obtained through the get method, which blocks until the task returns the result.

The Future class, located under the java.util.concurrent package, is an interface:

Public interface Future {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, and the following explains the role of each method in turn:

The cancel method is used to cancel the task, return true if the cancel task succeeds, and false if the cancel task fails. The parameter mayInterruptIfRunning indicates whether to cancel tasks that are in progress but are not finished, and if true is set, it means that tasks in progress can be canceled. If the task has been completed, whether mayInterruptIfRunning is true or false, this method must return false, that is, if canceling the completed task, it will return false;. If the task is executing, if mayInterruptIfRunning is set to true, it will return true. If mayInterruptIfRunning is set to false, it will return false;. If the task has not been executed, whether the mayInterruptIfRunning is true or false, it will definitely return true.

The isCancelled method indicates whether the task was successfully cancelled or not, and returns true if it is successfully cancelled before the task completes normally.

The isDone method indicates whether the task has been completed. If the task is completed, it returns true.

The get () method is used to get the execution result, which causes blocking and does not return until the task is finished.

Get (long timeout, TimeUnit unit) is used to get the execution result. If the result has not been obtained within the specified time, it will directly return null.

Because Future is only an interface, it cannot be used directly to create objects, so you have the following FutureTask.

# FutureTask

Public class FutureTask implements RunnableFuture {} public interface RunnableFuture extends Runnable, Future {void run ();}

You can see that RunnableFuture inherits the Runnable interface and the Future interface, while FutureTask implements the RunnableFuture interface. So it can be executed by the thread either as Runnable or as Future to get the return value of Callable.

FutureTask provides two constructors:

Public FutureTask (Callable callable) {} public FutureTask (Runnable runnable, V result) {}

In fact, FutureTask is the only implementation class of the Future interface. # examples of use

Public class Test {public static void main (String [] args) {ExecutorService executor = Executors.newCachedThreadPool (); Task task = new Task (); Future result = executor.submit (task); executor.shutdown (); / / second way / / ExecutorService executor = Executors.newCachedThreadPool (); / / Task task = new Task (); / / FutureTask futureTask = new FutureTask (task) / / executor.submit (futureTask); / / executor.shutdown (); / / third, note that the effect of this method is similar to that of the second method, except that one uses ExecutorService and the other uses Thread / / Task task = new Task (); / / FutureTask futureTask = new FutureTask (task); / / Thread thread = new Thread (futureTask); / / thread.start () Try {Thread.sleep (1000);} catch (InterruptedException E1) {e1.printStackTrace ();} System.out.println ("main thread is executing a task"); try {System.out.println ("task run result" + result.get ());} catch (InterruptedException e) {e.printStackTrace () } catch (ExecutionException e) {e.printStackTrace ();} System.out.println ("all tasks have been executed");}} class Task implements Callable {@ Override public Integer call () throws Exception {System.out.println ("child threads are calculating"); Thread.sleep (3000); int sum = 0; for (int iThreads)

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.