com.google.common.util.concurrent

## Class ExecutionList

- java.lang.Object
- - com.google.common.util.concurrent.ExecutionList

-     public final class ExecutionList
      extends java.lang.Object

  A support class for `ListenableFuture` implementations to manage their listeners. An instance contains a list of listeners, each with an associated `Executor`, and 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.

  Since:
    1.0

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `ExecutionList()` Creates a new, empty `ExecutionList`.

  - ### Method Summary

    Methods
    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.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### ExecutionList

          public ExecutionList()

      Creates a new, empty `ExecutionList`.

  - ### Method Detail

    - #### add

          public void add(java.lang.Runnable runnable,
                 java.util.concurrent.Executor executor)

      Adds the `Runnable` and accompanying `Executor` to the list of listeners to execute. If execution has already begun, the listener is executed immediately.

      When selecting an executor, note that `directExecutor` is dangerous in some cases. See the discussion in the `ListenableFuture.addListener` documentation.

    - #### execute

          public void execute()

      Runs this execution list, executing all existing pairs in the order they were added. However, note that listeners added after this point may be executed before those previously added, and note that the execution order of all listeners is ultimately chosen by the implementations of the supplied executors.

      This method is idempotent. Calling it several times in parallel is semantically equivalent to calling it exactly once.

      Since:
        10.0 (present in 1.0 as `run`)