Module java.base
Package java.util.concurrent

# Class AbstractExecutorService

java.lang.Object
java.util.concurrent.AbstractExecutorService

All Implemented Interfaces:
  `Executor`, `ExecutorService`

Direct Known Subclasses:
  `ForkJoinPool`, `ThreadPoolExecutor`

    public abstract class AbstractExecutorService
    extends Object
    implements ExecutorService

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`:

     public class CustomThreadPoolExecutor extends ThreadPoolExecutor {

       static class CustomTask<V> implements RunnableFuture<V> {...}

       protected <V> RunnableFuture<V> newTaskFor(Callable<V> c) {
           return new CustomTask<V>(c);
       }
       protected <V> RunnableFuture<V> newTaskFor(Runnable r, V v) {
           return new CustomTask<V>(r, v);
       }
       // ... add constructors, etc.
     }

Since:
  1.5

## Constructor Summary

Constructors
Constructor | Description
--- | ---
`AbstractExecutorService()` |

## Method Summary

Modifier and Type | Method | Description
--- | --- | ---
`protected <T> RunnableFuture<T>` | `newTaskFor​(Runnable runnable, T value)` | Returns a `RunnableFuture` for the given runnable and default value.
`protected <T> RunnableFuture<T>` | `newTaskFor​(Callable<T> callable)` | Returns a `RunnableFuture` for the given callable task.
`Future<?>` | `submit​(Runnable task)` | Submits a Runnable task for execution and returns a Future representing that task.
`<T> Future<T>` | `submit​(Runnable task, T result)` | Submits a Runnable task for execution and returns a Future representing that task.
`<T> Future<T>` | `submit​(Callable<T> task)` | Submits a value-returning task for execution and returns a Future representing the pending results of the task.

### Methods declared in class java.lang.Object

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

### Methods declared in interface java.util.concurrent.Executor

`execute`

### Methods declared in interface java.util.concurrent.ExecutorService

`awaitTermination, invokeAll, invokeAll, invokeAny, invokeAny, isShutdown, isTerminated, shutdown, shutdownNow`

## Constructor Details

### AbstractExecutorService

public AbstractExecutorService()

## Method Details

### newTaskFor

protected <T> RunnableFuture<T> newTaskFor​(Runnable runnable, T value)
Returns a `RunnableFuture` for the given runnable and default value.

Type Parameters:
  `T` - the type of the given value
Parameters:
  `runnable` - the runnable task being wrapped
  `value` - the default value for the returned future
Returns:
  a `RunnableFuture` which, when run, will run the underlying runnable and which, as a `Future`, will yield the given value as its result and provide for cancellation of the underlying task
Since:
  1.6

### newTaskFor

protected <T> RunnableFuture<T> newTaskFor​(Callable<T> callable)
Returns a `RunnableFuture` for the given callable task.

Type Parameters:
  `T` - the type of the callable's result
Parameters:
  `callable` - the callable task being wrapped
Returns:
  a `RunnableFuture` which, when run, will call the underlying callable and which, as a `Future`, will yield the callable's result as its result and provide for cancellation of the underlying task
Since:
  1.6

### submit

public Future<?> submit​(Runnable task)
Description copied from interface: `ExecutorService`
Submits a Runnable task for execution and returns a Future representing that task. The Future's `get` method will return `null` upon successful completion.

Specified by:
  `submit` in interface `ExecutorService`
Parameters:
  `task` - the task to submit
Returns:
  a Future representing pending completion of the task
Throws:
  `RejectedExecutionException` - if the task cannot be scheduled for execution
  `NullPointerException` - if the task is null

### submit

public <T> Future<T> submit​(Runnable task, T result)
Description copied from interface: `ExecutorService`
Submits a Runnable task for execution and returns a Future representing that task. The Future's `get` method will return the given result upon successful completion.

Specified by:
  `submit` in interface `ExecutorService`
Type Parameters:
  `T` - the type of the result
Parameters:
  `task` - the task to submit
  `result` - the result to return
Returns:
  a Future representing pending completion of the task
Throws:
  `RejectedExecutionException` - if the task cannot be scheduled for execution
  `NullPointerException` - if the task is null

### submit

public <T> Future<T> submit​(Callable<T> task)
Description copied from interface: `ExecutorService`
Submits a value-returning task for execution and returns a Future representing the pending results of the task. The Future's `get` method will return the task's result upon successful completion.

If you would like to immediately block waiting for a task, you can use constructions of the form `result = exec.submit(aCallable).get();`

Note: The `Executors` class includes a set of methods that can convert some other common closure-like objects, for example, `PrivilegedAction` to `Callable` form so they can be submitted.

Specified by:
  `submit` in interface `ExecutorService`
Type Parameters:
  `T` - the type of the task's result
Parameters:
  `task` - the task to submit
Returns:
  a Future representing pending completion of the task
Throws:
  `RejectedExecutionException` - if the task cannot be scheduled for execution
  `NullPointerException` - if the task is null