Added in API level 1

AbstractExecutorService

abstract class AbstractExecutorService : ExecutorService

kotlin.Any
↳	java.util.concurrent.AbstractExecutorService

Known Direct Subclasses

ForkJoinPool, ThreadPoolExecutor

ForkJoinPool	An `ExecutorService` for running `ForkJoinTask`s.
ThreadPoolExecutor	An `ExecutorService` that executes each submitted task using one of possibly several pooled threads, normally configured using `Executors` factory methods.

Known Indirect Subclasses

ScheduledThreadPoolExecutor

A ThreadPoolExecutor that can additionally schedule commands to run after a given delay, or to execute periodically.

Provides default implementations of ExecutorService execution methods. This class implements the submit, invokeAny and invokeAll methods using a RunnableFuture returned by newTaskFor, which defaults to the FutureTask class provided in this package. For example, the implementation of submit(Runnable) creates an associated RunnableFuture that is executed and returned. Subclasses may override the newTaskFor methods to return RunnableFuture implementations other than FutureTask.

Extension example. Here is a sketch of a class that customizes ThreadPoolExecutor to use a CustomTask class instead of the default FutureTask:

<code>public class CustomThreadPoolExecutor extends ThreadPoolExecutor {
 
    static class CustomTask&lt;V&gt; implements RunnableFuture&lt;V&gt; { ... }
 
    protected &lt;V&gt; RunnableFuture&lt;V&gt; newTaskFor(Callable&lt;V&gt; c) {
        return new CustomTask&lt;V&gt;(c);
    }
    protected &lt;V&gt; RunnableFuture&lt;V&gt; newTaskFor(Runnable r, V v) {
        return new CustomTask&lt;V&gt;(r, v);
    }
    // ... add constructors, etc.
  }</code>

Summary

Public constructors
`AbstractExecutorService()` Constructor for subclasses to call.

Public methods
open MutableList<Future<T>!>!	`invokeAll(tasks: MutableCollection<out Callable<T>!>!)`
open MutableList<Future<T>!>!	`invokeAll(tasks: MutableCollection<out Callable<T>!>!, timeout: Long, unit: TimeUnit!)`
open T	`invokeAny(tasks: MutableCollection<out Callable<T>!>!)`
open T	`invokeAny(tasks: MutableCollection<out Callable<T>!>!, timeout: Long, unit: TimeUnit!)`
open Future<*>!	`submit(task: Runnable!)`
open Future<T>!	`submit(task: Runnable!, result: T)`
open Future<T>!	`submit(task: Callable<T>!)`

Protected methods
open RunnableFuture<T>!	`newTaskFor(runnable: Runnable!, value: T)` Returns a `RunnableFuture` for the given runnable and default value.
open RunnableFuture<T>!	`newTaskFor(callable: Callable<T>!)` Returns a `RunnableFuture` for the given callable task.

Inherited functions

From class ExecutorService

`Boolean`	`awaitTermination(timeout: Long, unit: TimeUnit!)` Blocks until all tasks have completed execution after a shutdown request, or the timeout occurs, or the current thread is interrupted, whichever happens first.
`Boolean`	`isShutdown()` Returns `true` if this executor has been shut down.
`Boolean`	`isTerminated()` Returns `true` if all tasks have completed following shut down. Note that `isTerminated` is never `true` unless either `shutdown` or `shutdownNow` was called first.
`Unit`	`shutdown()` Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted. Invocation has no additional effect if already shut down. This method does not wait for previously submitted tasks to complete execution. Use `awaitTermination` to do that.
`MutableList<Runnable!>!`	`shutdownNow()` Attempts to stop all actively executing tasks, halts the processing of waiting tasks, and returns a list of the tasks that were awaiting execution. This method does not wait for actively executing tasks to terminate. Use `awaitTermination` to do that. There are no guarantees beyond best-effort attempts to stop processing actively executing tasks. For example, typical implementations will cancel via `Thread#interrupt`, so any task that fails to respond to interrupts may never terminate.

From class Executor

Unit

execute(command: Runnable!)

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.

Public constructors