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

```
@GwtCompatible(emulated=true)
public final class MoreExecutors
extends java.lang.Object
```
Factory and utility methods for Executor, ExecutorService, and ThreadFactory.

Since:

3.0

Author:

Eric Fellheimer, Kyle Littlefield, Justin Mahoney

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static void`	`addDelayedShutdownHook(java.util.concurrent.ExecutorService service, long terminationTimeout, java.util.concurrent.TimeUnit timeUnit)`	Add a shutdown hook to wait for thread completion in the given `service`.
`static java.util.concurrent.Executor`	`directExecutor()`	Returns an `Executor` that runs each task in the thread that invokes `execute`, as in `ThreadPoolExecutor.CallerRunsPolicy`.
`static java.util.concurrent.ExecutorService`	`getExitingExecutorService(java.util.concurrent.ThreadPoolExecutor executor)`	Converts the given ThreadPoolExecutor into an ExecutorService that exits when the application is complete.
`static java.util.concurrent.ExecutorService`	`getExitingExecutorService(java.util.concurrent.ThreadPoolExecutor executor, long terminationTimeout, java.util.concurrent.TimeUnit timeUnit)`	Converts the given ThreadPoolExecutor into an ExecutorService that exits when the application is complete.
`static java.util.concurrent.ScheduledExecutorService`	`getExitingScheduledExecutorService(java.util.concurrent.ScheduledThreadPoolExecutor executor)`	Converts the given ScheduledThreadPoolExecutor into a ScheduledExecutorService that exits when the application is complete.
`static java.util.concurrent.ScheduledExecutorService`	`getExitingScheduledExecutorService(java.util.concurrent.ScheduledThreadPoolExecutor executor, long terminationTimeout, java.util.concurrent.TimeUnit timeUnit)`	Converts the given ScheduledThreadPoolExecutor into a ScheduledExecutorService that exits when the application is complete.
`static ListeningExecutorService`	`listeningDecorator(java.util.concurrent.ExecutorService delegate)`	Creates an `ExecutorService` whose `submit` and `invokeAll` methods submit `ListenableFutureTask` instances to the given delegate executor.
`static ListeningScheduledExecutorService`	`listeningDecorator(java.util.concurrent.ScheduledExecutorService delegate)`	Creates a `ScheduledExecutorService` whose `submit` and `invokeAll` methods submit `ListenableFutureTask` instances to the given delegate executor.
`static ListeningExecutorService`	`newDirectExecutorService()`	Creates an executor service that runs each task in the thread that invokes `execute/submit`, as in `ThreadPoolExecutor.CallerRunsPolicy`.
`static java.util.concurrent.Executor`	`newSequentialExecutor(java.util.concurrent.Executor delegate)`	Returns an `Executor` that runs each task executed sequentially, such that no two tasks are running concurrently.
`static java.util.concurrent.ThreadFactory`	`platformThreadFactory()`	Returns a default thread factory used to create new threads.
`static boolean`	`shutdownAndAwaitTermination(java.util.concurrent.ExecutorService service, long timeout, java.util.concurrent.TimeUnit unit)`	Shuts down the given executor service gradually, first disabling new submissions and later, if necessary, cancelling remaining tasks.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - getExitingExecutorService
```
@GwtIncompatible
public static java.util.concurrent.ExecutorService getExitingExecutorService(java.util.concurrent.ThreadPoolExecutor executor,
                                                                             long terminationTimeout,
                                                                             java.util.concurrent.TimeUnit timeUnit)
```
    Converts the given ThreadPoolExecutor into an ExecutorService that exits when the application is complete. It does so by using daemon threads and adding a shutdown hook to wait for their completion.
    This is mainly for fixed thread pools. See Executors.newFixedThreadPool(int).
    
    Parameters:
    
    executor - the executor to modify to make sure it exits when the application is finished
    
    terminationTimeout - how long to wait for the executor to finish before terminating the JVM
    
    timeUnit - unit of time for the time parameter
    
    Returns:
    
    an unmodifiable version of the input which will not hang the JVM
  - getExitingExecutorService
```
@GwtIncompatible
public static java.util.concurrent.ExecutorService getExitingExecutorService(java.util.concurrent.ThreadPoolExecutor executor)
```
    Converts the given ThreadPoolExecutor into an ExecutorService that exits when the application is complete. It does so by using daemon threads and adding a shutdown hook to wait for their completion.
    This method waits 120 seconds before continuing with JVM termination, even if the executor has not finished its work.
    This is mainly for fixed thread pools. See Executors.newFixedThreadPool(int).
    
    Parameters:
    
    executor - the executor to modify to make sure it exits when the application is finished
    
    Returns:
    
    an unmodifiable version of the input which will not hang the JVM
  - getExitingScheduledExecutorService
```
@GwtIncompatible
public static java.util.concurrent.ScheduledExecutorService getExitingScheduledExecutorService(java.util.concurrent.ScheduledThreadPoolExecutor executor,
                                                                                               long terminationTimeout,
                                                                                               java.util.concurrent.TimeUnit timeUnit)
```
    Converts the given ScheduledThreadPoolExecutor into a ScheduledExecutorService that exits when the application is complete. It does so by using daemon threads and adding a shutdown hook to wait for their completion.
    This is mainly for fixed thread pools. See Executors.newScheduledThreadPool(int).
    
    Parameters:
    
    executor - the executor to modify to make sure it exits when the application is finished
    
    terminationTimeout - how long to wait for the executor to finish before terminating the JVM
    
    timeUnit - unit of time for the time parameter
    
    Returns:
    
    an unmodifiable version of the input which will not hang the JVM
  - getExitingScheduledExecutorService
```
@GwtIncompatible
public static java.util.concurrent.ScheduledExecutorService getExitingScheduledExecutorService(java.util.concurrent.ScheduledThreadPoolExecutor executor)
```
    Converts the given ScheduledThreadPoolExecutor into a ScheduledExecutorService that exits when the application is complete. It does so by using daemon threads and adding a shutdown hook to wait for their completion.
    This method waits 120 seconds before continuing with JVM termination, even if the executor has not finished its work.
    This is mainly for fixed thread pools. See Executors.newScheduledThreadPool(int).
    
    Parameters:
    
    executor - the executor to modify to make sure it exits when the application is finished
    
    Returns:
    
    an unmodifiable version of the input which will not hang the JVM
  - addDelayedShutdownHook
```
@GwtIncompatible
public static void addDelayedShutdownHook(java.util.concurrent.ExecutorService service,
                                          long terminationTimeout,
                                          java.util.concurrent.TimeUnit timeUnit)
```
    Add a shutdown hook to wait for thread completion in the given service. This is useful if the given service uses daemon threads, and we want to keep the JVM from exiting immediately on shutdown, instead giving these daemon threads a chance to terminate normally.
    
    Parameters:
    
    service - ExecutorService which uses daemon threads
    
    terminationTimeout - how long to wait for the executor to finish before terminating the JVM
    
    timeUnit - unit of time for the time parameter
  - newDirectExecutorService
```
@GwtIncompatible
public static ListeningExecutorService newDirectExecutorService()
```
    Creates an executor service that runs each task in the thread that invokes execute/submit, as in ThreadPoolExecutor.CallerRunsPolicy. This applies both to individually submitted tasks and to collections of tasks submitted via invokeAll or invokeAny. In the latter case, tasks will run serially on the calling thread. Tasks are run to completion before a Future is returned to the caller (unless the executor has been shutdown).
    Although all tasks are immediately executed in the thread that submitted the task, this ExecutorService imposes a small locking overhead on each task submission in order to implement shutdown and termination behavior.
    The implementation deviates from the ExecutorService specification with regards to the shutdownNow method. First, "best-effort" with regards to canceling running tasks is implemented as "no-effort". No interrupts or other attempts are made to stop threads executing tasks. Second, the returned list will always be empty, as any submitted task is considered to have started execution. This applies also to tasks given to invokeAll or invokeAny which are pending serial execution, even the subset of the tasks that have not yet started execution. It is unclear from the ExecutorService specification if these should be included, and it's much easier to implement the interpretation that they not be. Finally, a call to shutdown or shutdownNow may result in concurrent calls to invokeAll/invokeAny throwing RejectedExecutionException, although a subset of the tasks may already have been executed.
    
    Since:
    
    18.0 (present as MoreExecutors.sameThreadExecutor() since 10.0)
  - directExecutor
```
public static java.util.concurrent.Executor directExecutor()
```
    Returns an Executor that runs each task in the thread that invokes execute, as in ThreadPoolExecutor.CallerRunsPolicy.
    This executor is appropriate for tasks that are lightweight and not deeply chained. Inappropriate directExecutor usage can cause problems, and these problems can be difficult to reproduce because they depend on timing. For example:
    
    When a ListenableFuture listener is registered to run under directExecutor, the listener can execute in any of three possible threads:
    
    When a thread attaches a listener to a ListenableFuture that's already complete, the listener runs immediately in that thread.
    When a thread attaches a listener to a ListenableFuture that's incomplete and the ListenableFuture later completes normally, the listener runs in the thread that completes the ListenableFuture.
    When a listener is attached to a ListenableFuture and the ListenableFuture gets cancelled, the listener runs immediately in the thread that cancelled the Future.
    Given all these possibilities, it is frequently possible for listeners to execute in UI threads, RPC network threads, or other latency-sensitive threads. In those cases, slow listeners can harm responsiveness, slow the system as a whole, or worse. (See also the note about locking below.)
    If many tasks will be triggered by the same event, one heavyweight task may delay other tasks -- even tasks that are not themselves directExecutor tasks.
    If many such tasks are chained together (such as with future.transform(...).transform(...).transform(...)....), they may overflow the stack. (In simple cases, callers can avoid this by registering all tasks with the same newSequentialExecutor(java.util.concurrent.Executor) wrapper around directExecutor(). More complex cases may require using thread pools or making deeper changes.)
    If an exception propagates out of a Runnable, it is not necessarily seen by any UncaughtExceptionHandler for the thread. For example, if the callback passed to Futures.addCallback(com.google.common.util.concurrent.ListenableFuture<V>, com.google.common.util.concurrent.FutureCallback<? super V>, java.util.concurrent.Executor) throws an exception, that exception will be typically be logged by the ListenableFuture implementation, even if the thread is configured to do something different. In other cases, no code will catch the exception, and it may terminate whichever thread happens to trigger the execution.
    A specific warning about locking: Code that executes user-supplied tasks, such as ListenableFuture listeners, should take care not to do so while holding a lock. Additionally, as a further line of defense, prefer not to perform any locking inside a task that will be run under directExecutor: Not only might the wait for a lock be long, but if the running thread was holding a lock, the listener may deadlock or break lock isolation.
    This instance is equivalent to:
    final class DirectExecutor implements Executor { public void execute(Runnable r) { r.run(); } }
    
    This should be preferred to newDirectExecutorService() because implementing the ExecutorService subinterface necessitates significant performance overhead.
    Since:
    
    18.0
  - newSequentialExecutor
```
@GwtIncompatible
public static java.util.concurrent.Executor newSequentialExecutor(java.util.concurrent.Executor delegate)
```
    Returns an Executor that runs each task executed sequentially, such that no two tasks are running concurrently.
    executed tasks have a happens-before order as defined in the Java Language Specification. Tasks execute with the same happens-before order that the function calls to `execute()` that submitted those tasks had.
    The executor uses delegate in order to execute each task in turn, and does not create any threads of its own.
    After execution begins on a thread from the delegate Executor, tasks are polled and executed from a task queue until there are no more tasks. The thread will not be released until there are no more tasks to run.
    If a task is submitted while a thread is executing tasks from the task queue, the thread will not be released until that submitted task is also complete.
    If a task is interrupted while a task is running:
    
    execution will not stop until the task queue is empty.
    tasks will begin execution with the thread marked as not interrupted - any interruption applies only to the task that was running at the point of interruption.
    if the thread was interrupted before the SequentialExecutor's worker begins execution, the interrupt will be restored to the thread after it completes so that its delegate Executor may process the interrupt.
    subtasks are run with the thread uninterrupted and interrupts received during execution of a task are ignored.
    
    RuntimeExceptions thrown by tasks are simply logged and the executor keeps trucking. If an Error is thrown, the error will propagate and execution will stop until the next time a task is submitted.
    When an Error is thrown by an executed task, previously submitted tasks may never run. An attempt will be made to restart execution on the next call to execute. If the delegate has begun to reject execution, the previously submitted tasks may never run, despite not throwing a RejectedExecutionException synchronously with the call to execute. If this behaviour is problematic, use an Executor with a single thread (e.g. Executors.newSingleThreadExecutor()).
    Since:
    
    23.3 (since 23.1 as sequentialExecutor)
  - listeningDecorator
```
@GwtIncompatible
public static ListeningExecutorService listeningDecorator(java.util.concurrent.ExecutorService delegate)
```
    Creates an ExecutorService whose submit and invokeAll methods submit ListenableFutureTask instances to the given delegate executor. Those methods, as well as execute and invokeAny, are implemented in terms of calls to delegate.execute. All other methods are forwarded unchanged to the delegate. This implies that the returned ListeningExecutorService never calls the delegate's submit, invokeAll, and invokeAny methods, so any special handling of tasks must be implemented in the delegate's execute method or by wrapping the returned ListeningExecutorService.
    If the delegate executor was already an instance of ListeningExecutorService, it is returned untouched, and the rest of this documentation does not apply.
    
    Since:
    
    10.0
  - listeningDecorator
```
@GwtIncompatible
public static ListeningScheduledExecutorService listeningDecorator(java.util.concurrent.ScheduledExecutorService delegate)
```
    Creates a ScheduledExecutorService whose submit and invokeAll methods submit ListenableFutureTask instances to the given delegate executor. Those methods, as well as execute and invokeAny, are implemented in terms of calls to delegate.execute. All other methods are forwarded unchanged to the delegate. This implies that the returned ListeningScheduledExecutorService never calls the delegate's submit, invokeAll, and invokeAny methods, so any special handling of tasks must be implemented in the delegate's execute method or by wrapping the returned ListeningScheduledExecutorService.
    If the delegate executor was already an instance of ListeningScheduledExecutorService, it is returned untouched, and the rest of this documentation does not apply.
    
    Since:
    
    10.0
  - platformThreadFactory
```
@GwtIncompatible
public static java.util.concurrent.ThreadFactory platformThreadFactory()
```
    Returns a default thread factory used to create new threads.
    When running on AppEngine with access to AppEngine legacy APIs, this method returns ThreadManager.currentRequestThreadFactory(). Otherwise, it returns Executors.defaultThreadFactory().
    
    Since:
    
    14.0
  - shutdownAndAwaitTermination
```
@CanIgnoreReturnValue
@GwtIncompatible
public static boolean shutdownAndAwaitTermination(java.util.concurrent.ExecutorService service,
                                                  long timeout,
                                                  java.util.concurrent.TimeUnit unit)
```
    Shuts down the given executor service gradually, first disabling new submissions and later, if necessary, cancelling remaining tasks.
    The method takes the following steps:
    
    calls ExecutorService.shutdown(), disabling acceptance of new submitted tasks.
    awaits executor service termination for half of the specified timeout.
    if the timeout expires, it calls ExecutorService.shutdownNow(), cancelling pending tasks and interrupting running tasks.
    awaits executor service termination for the other half of the specified timeout.
    
    If, at any step of the process, the calling thread is interrupted, the method calls ExecutorService.shutdownNow() and returns.
    Parameters:
    
    service - the ExecutorService to shut down
    
    timeout - the maximum time to wait for the ExecutorService to terminate
    
    unit - the time unit of the timeout argument
    
    Returns:
    
    true if the ExecutorService was terminated successfully, false if the call timed out or was interrupted
    
    Since:
    
    17.0

Class MoreExecutors

Method Summary

Methods inherited from class java.lang.Object

Method Detail

getExitingExecutorService

getExitingExecutorService

getExitingScheduledExecutorService

getExitingScheduledExecutorService

addDelayedShutdownHook

newDirectExecutorService

directExecutor

newSequentialExecutor

listeningDecorator

listeningDecorator

platformThreadFactory

shutdownAndAwaitTermination