Added in [API level 1](https://developer.android.com/guide/topics/manifest/uses-sdk-element#ApiLevels) Summary: [Methods](https://developer.android.com/reference/java/util/concurrent/Executor#pubmethods)

# Executor

` public interface Executor `   
` `

|---|
| java.util.concurrent.Executor |

Known indirect subclasses [AbstractExecutorService](https://developer.android.com/reference/java/util/concurrent/AbstractExecutorService), [ExecutorService](https://developer.android.com/reference/java/util/concurrent/ExecutorService), [ForkJoinPool](https://developer.android.com/reference/java/util/concurrent/ForkJoinPool), [ScheduledExecutorService](https://developer.android.com/reference/java/util/concurrent/ScheduledExecutorService), [ScheduledThreadPoolExecutor](https://developer.android.com/reference/java/util/concurrent/ScheduledThreadPoolExecutor), [ThreadPoolExecutor](https://developer.android.com/reference/java/util/concurrent/ThreadPoolExecutor) [AbstractExecutorService](https://developer.android.com/reference/java/util/concurrent/AbstractExecutorService) Provides default implementations of `https://developer.android.com/reference/java/util/concurrent/ExecutorService` execution methods. [ExecutorService](https://developer.android.com/reference/java/util/concurrent/ExecutorService) An `https://developer.android.com/reference/java/util/concurrent/Executor` that provides methods to manage termination and methods that can produce a `https://developer.android.com/reference/java/util/concurrent/Future` for tracking progress of one or more asynchronous tasks. [ForkJoinPool](https://developer.android.com/reference/java/util/concurrent/ForkJoinPool) An `https://developer.android.com/reference/java/util/concurrent/ExecutorService` for running `https://developer.android.com/reference/java/util/concurrent/ForkJoinTask`s. [ScheduledExecutorService](https://developer.android.com/reference/java/util/concurrent/ScheduledExecutorService) An `https://developer.android.com/reference/java/util/concurrent/ExecutorService` that can schedule commands to run after a given delay, or to execute periodically. [ScheduledThreadPoolExecutor](https://developer.android.com/reference/java/util/concurrent/ScheduledThreadPoolExecutor) A `https://developer.android.com/reference/java/util/concurrent/ThreadPoolExecutor` that can additionally schedule commands to run after a given delay, or to execute periodically. [ThreadPoolExecutor](https://developer.android.com/reference/java/util/concurrent/ThreadPoolExecutor) An `https://developer.android.com/reference/java/util/concurrent/ExecutorService` that executes each submitted task using one of possibly several pooled threads, normally configured using `https://developer.android.com/reference/java/util/concurrent/Executors` factory methods.   

*** ** * ** ***

An object that executes submitted `https://developer.android.com/reference/java/lang/Runnable` tasks. This interface provides a way of decoupling task submission from the mechanics of how each task will be run, including details of thread use, scheduling, etc. An `Executor` is normally used instead of explicitly creating threads. For example, rather than invoking `new Thread(new RunnableTask()).start()` for each of a set of tasks, you might use:

    Executor executor = anExecutor();
    executor.execute(new RunnableTask1());
    executor.execute(new RunnableTask2());
    ...

However, the `Executor` interface does not strictly require that execution be asynchronous. In the simplest case, an executor can run the submitted task immediately in the caller's thread:

    class DirectExecutor implements Executor {
      public void execute(Runnable r) {
        r.run();
      }
    }

More typically, tasks are executed in some thread other than the caller's thread. The executor below spawns a new thread for each task.

    class ThreadPerTaskExecutor implements Executor {
      public void execute(Runnable r) {
        new Thread(r).start();
      }
    }

Many `Executor` implementations impose some sort of limitation on how and when tasks are scheduled. The executor below serializes the submission of tasks to a second executor, illustrating a composite executor.

    class SerialExecutor implements Executor {
      final Queue<Runnable> tasks = new ArrayDeque<>();
      final Executor executor;
      Runnable active;

      SerialExecutor(Executor executor) {
        this.executor = executor;
      }

      public synchronized void execute(Runnable r) {
        tasks.add(() -> {
          try {
            r.run();
          } finally {
            scheduleNext();
          }
        });
        if (active == null) {
          scheduleNext();
        }
      }

      protected synchronized void scheduleNext() {
        if ((active = tasks.poll()) != null) {
          executor.execute(active);
        }
      }
    }

The `Executor` implementations provided in this package implement `https://developer.android.com/reference/java/util/concurrent/ExecutorService`, which is a more extensive interface. The `https://developer.android.com/reference/java/util/concurrent/ThreadPoolExecutor` class provides an extensible thread pool implementation. The `https://developer.android.com/reference/java/util/concurrent/Executors` class provides convenient factory methods for these Executors.

Memory consistency effects: Actions in a thread prior to submitting a `Runnable` object to an `Executor` [*happen-before*](https://developer.android.com/reference/java/util/concurrent/package-summary#MemoryVisibility) its execution begins, perhaps in another thread.

## Summary

| ### Public methods ||
|---|---|
| ` abstract void` | ` https://developer.android.com/reference/java/util/concurrent/Executor#execute(java.lang.Runnable)(https://developer.android.com/reference/java/lang/Runnable command) ` Executes the given command at some time in the future. |

## Public methods

### execute

Added in [API level 1](https://developer.android.com/guide/topics/manifest/uses-sdk-element#ApiLevels)

```
public abstract void execute (Runnable command)
```

Executes the given command at some time in the future. The command may execute in a new thread, in a pooled thread, or in the calling thread, at the discretion of the `Executor` implementation.

<br />

| Parameters ||
|---|---|
| `command` | `Runnable`: the runnable task <br /> |

| Throws ||
|---|---|
| `https://developer.android.com/reference/java/lang/NullPointerException` | if command is null |
| `https://developer.android.com/reference/java/util/concurrent/RejectedExecutionException` | if this task cannot be accepted for execution |