V - The result type returned by this FutureTask's get methodspublic class FutureTask<V> extends Object implements RunnableFuture<V>
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 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
runAndReset()).
A FutureTask can be used to wrap a Callable or
Runnable object. Because FutureTask implements
Runnable, a FutureTask can be submitted to an
Executor for execution.
In addition to serving as a standalone class, this class provides
protected functionality that may be useful when creating
customized task classes.
| Constructor and Description |
|---|
FutureTask(Callable<V> callable)
Creates a
FutureTask that will, upon running, execute the
given Callable. |
FutureTask(Runnable runnable,
V result)
Creates a
FutureTask that will, upon running, execute the
given Runnable, and arrange that get will return the
given result on successful completion. |
| Modifier and Type | Method and Description |
|---|---|
boolean |
cancel(boolean mayInterruptIfRunning)
Attempts to cancel execution of this task.
|
protected void |
done()
Protected method invoked when this task transitions to state
isDone (whether normally or via cancellation). |
V |
get()
Waits if necessary for the computation to complete, and then
retrieves its result.
|
V |
get(long timeout,
TimeUnit unit)
Waits if necessary for at most the given time for the computation
to complete, and then retrieves its result, if available.
|
boolean |
isCancelled()
Returns
true if this task was cancelled before it completed
normally. |
boolean |
isDone()
Returns
true if this task completed. |
void |
run()
Sets this Future to the result of its computation
unless it has been cancelled.
|
protected boolean |
runAndReset()
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.
|
protected void |
set(V v)
Sets the result of this future to the given value unless
this future has already been set or has been cancelled.
|
protected void |
setException(Throwable t)
Causes this future to report an
ExecutionException
with the given throwable as its cause, unless this future has
already been set or has been cancelled. |
public FutureTask(Callable<V> callable)
FutureTask that will, upon running, execute the
given Callable.callable - the callable taskNullPointerException - if the callable is nullpublic FutureTask(Runnable runnable, V result)
FutureTask that will, upon running, execute the
given Runnable, and arrange that get will return the
given result on successful completion.runnable - the runnable taskresult - the result to return on successful completion. If
you don't need a particular result, consider using
constructions of the form:
Future<?> f = new FutureTask<Void>(runnable, null)NullPointerException - if the runnable is nullpublic boolean isCancelled()
Futuretrue if this task was cancelled before it completed
normally.isCancelled in interface Future<V>true if this task was cancelled before it completedpublic boolean isDone()
Futuretrue if this task completed.
Completion may be due to normal termination, an exception, or
cancellation -- in all of these cases, this method will return
true.public boolean cancel(boolean mayInterruptIfRunning)
Futurecancel is called,
this task should never run. If the task has already started,
then the mayInterruptIfRunning parameter determines
whether the thread executing this task should be interrupted in
an attempt to stop the task.
After this method returns, subsequent calls to Future.isDone() will
always return true. Subsequent calls to Future.isCancelled()
will always return true if this method returned true.
cancel in interface Future<V>mayInterruptIfRunning - true if the thread executing this
task should be interrupted; otherwise, in-progress tasks are allowed
to completefalse if the task could not be cancelled,
typically because it has already completed normally;
true otherwisepublic V get() throws InterruptedException, ExecutionException
Futureget in interface Future<V>CancellationException - if the computation was cancelledInterruptedException - if the current thread was interrupted
while waitingExecutionException - if the computation threw an
exceptionpublic V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException
Futureget in interface Future<V>timeout - the maximum time to waitunit - the time unit of the timeout argumentCancellationException - if the computation was cancelledInterruptedException - if the current thread was interrupted
while waitingExecutionException - if the computation threw an
exceptionTimeoutException - if the wait timed outprotected void done()
isDone (whether normally or via cancellation). The
default implementation does nothing. Subclasses may override
this method to invoke completion callbacks or perform
bookkeeping. Note that you can query status inside the
implementation of this method to determine whether this task
has been cancelled.protected void set(V v)
This method is invoked internally by the run() method
upon successful completion of the computation.
v - the valueprotected void setException(Throwable t)
ExecutionException
with the given throwable as its cause, unless this future has
already been set or has been cancelled.
This method is invoked internally by the run() method
upon failure of the computation.
t - the cause of failurepublic void run()
RunnableFuturerun in interface Runnablerun in interface RunnableFuture<V>Thread.run()protected boolean runAndReset()
true if successfully run and reset Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2022, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.