- All Known Subinterfaces:
- ExecutorService
- All Known Implementing Classes:
- PooledExecutor, QueuedExecutor, ThreadSerializingExecutor
- public interface Executor
An object that executes submitted 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.
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();
}
}
However, tasks are typically executed in a different thread 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();
}
}
Most
Executor implementations will 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 {
LinkedBlockingQueue tasks = new LinkedBlockingQueue();
Executor executor;
Runnable active;
SerialExecutor(Executor executor) {
this.executor = executor;
}
public synchronized void execute(final Runnable r) {
tasks.offer(new Runnable() {
public void run() {
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
edu.emory.mathcs.util.concurrent implement
ExecutorService,
which is a more extensive interface. For more advanced users, the
ThreadPoolExecutor class provides a powerful, extensible
thread pool implementation. The
Executors class provides
convenient factory methods for these executors.
- Since:
- 1.5
execute
public void execute(java.lang.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.