public final class ExecutionList
extends java.lang.Object
A list of listeners, each with an associated Executor
, that
guarantees that every Runnable
that is added will
be executed after execute()
is called. Any Runnable
added
after the call to execute
is still guaranteed to execute. There is no
guarantee, however, that listeners will be executed in the order that they
are added.
Exceptions thrown by a listener will be propagated up to the executor.
Any exception thrown during Executor.execute
(e.g., a RejectedExecutionException
or an exception thrown by direct execution) will be caught and
logged.
Modifier and Type | Class and Description |
---|---|
private static class |
ExecutionList.RunnableExecutorPair |
Modifier and Type | Field and Description |
---|---|
private boolean |
executed |
(package private) static java.util.logging.Logger |
log |
private ExecutionList.RunnableExecutorPair |
runnables
The runnable, executor pairs to execute.
|
Constructor and Description |
---|
ExecutionList()
Creates a new, empty
ExecutionList . |
Modifier and Type | Method and Description |
---|---|
void |
add(java.lang.Runnable runnable,
java.util.concurrent.Executor executor)
Adds the
Runnable and accompanying Executor to the list of
listeners to execute. |
void |
execute()
Runs this execution list, executing all existing pairs in the order they
were added.
|
private static void |
executeListener(java.lang.Runnable runnable,
java.util.concurrent.Executor executor)
Submits the given runnable to the given
Executor catching and logging all
runtime exceptions thrown by the executor. |
static final java.util.logging.Logger log
private ExecutionList.RunnableExecutorPair runnables
ExecutionList.RunnableExecutorPair.next
field.private boolean executed
public ExecutionList()
ExecutionList
.public void add(java.lang.Runnable runnable, java.util.concurrent.Executor executor)
Runnable
and accompanying Executor
to the list of
listeners to execute. If execution has already begun, the listener is
executed immediately.
Note: For fast, lightweight listeners that would be safe to execute in
any thread, consider MoreExecutors.directExecutor()
. For heavier
listeners, directExecutor()
carries some caveats: First, the
thread that the listener runs in depends on whether the ExecutionList
has been executed at the time it is added. In particular,
listeners may run in the thread that calls add
. Second, the thread
that calls execute()
may be an internal implementation thread, such
as an RPC network thread, and directExecutor()
listeners may
run in this thread. Finally, during the execution of a directExecutor
listener, all other registered but unexecuted
listeners are prevented from running, even if those listeners are to run
in other executors.
public void execute()
This method is idempotent. Calling it several times in parallel is semantically equivalent to calling it exactly once.
run
)private static void executeListener(java.lang.Runnable runnable, java.util.concurrent.Executor executor)
Executor
catching and logging all
runtime exceptions thrown by the executor.