Java.util.concurrent: Difference between revisions
| Line 27: | Line 27: | ||
{{External|https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Callable.html}} | {{External|https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Callable.html}} | ||
A callable represents a task that returns a result and may throw an exception. Implementors define a single method with no arguments called call. The Callable interface is similar to Runnable, in that both are designed for classes whose instances are potentially executed by another thread. The difference between a Runnable and a Callable is that the Runnable does not return a result and cannot throw a checked exception. | A callable represents a task that returns a result and may throw an exception. Implementors define a single method with no arguments called call. The Callable interface is similar to Runnable, in that both are designed for classes whose instances are potentially executed by another thread. The difference between a Runnable and a Callable is that the Runnable does not return a result and cannot throw a checked exception. Callable tasks can be submitted for execution to [[Java.util.concurrent_Executors#future|executors]]. | ||
Callable tasks can be submitted for execution to [[Java.util.concurrent_Executors#future|executors]] | |||
==Future== | ==Future== | ||
Revision as of 14:19, 14 June 2017
External
Internal
Overview
java.util.concurrent is a collection of utility classes to use for concurrent programming.
Subjects
General Concepts
Callable
A callable represents a task that returns a result and may throw an exception. Implementors define a single method with no arguments called call. The Callable interface is similar to Runnable, in that both are designed for classes whose instances are potentially executed by another thread. The difference between a Runnable and a Callable is that the Runnable does not return a result and cannot throw a checked exception. Callable tasks can be submitted for execution to executors.
Future
A Future represents the result of an asynchronous computation. Future instances are returned by executors upon task submission.
Having access to the Future instance, the caller may check if the computation is complete, wait for its completion, and retrieve the result of the computation.
The result of the computation is retrieved with Future.get(), only when the computation has completed. The call will block if the computation is not ready.
The computation may be cancelled Future.cancel(). Once a computation has completed, the computation cannot be cancelled. Additional methods are provided to determine if the task completed normally or was cancelled.
It is possible to use a Future with the only purpose of canceling the task, without any interest in the result. If that is the case, declare types of the form Future<?> and return null as a result of the underlying task.