LazyExecutorService (util 2.0.0-RC1 API)

java.lang.Object
- com.google.cloud.hadoop.util.LazyExecutorService

All Implemented Interfaces:

java.util.concurrent.Executor, java.util.concurrent.ExecutorService
```
@GwtIncompatible
public final class LazyExecutorService
extends java.lang.Object
implements java.util.concurrent.ExecutorService
```
Defers execution to the time that a method that expresses interest in the result (get or isDone) is called on the Future. Execution is performed by a backing ExecutorService.
In essence, a returned Future represents a "canned" method call and once the call has been performed, the Future returns the cached result.
Both this class and the returned Future are thread-safe.

Author:

[email protected] (Torbjorn Gannholm), [email protected] (Jared Levy), [email protected] (Chris Povirk)

Constructor Summary

Constructors
Constructor and Description
`LazyExecutorService()` Creates an instance using a `MoreExecutors.newDirectExecutorService()` for the backing service.
`LazyExecutorService(java.util.concurrent.ExecutorService backingService)` Creates an instance using the given `ExecutorService` as the backing service.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`awaitTermination(long timeout, java.util.concurrent.TimeUnit unit)`
`void`	`execute(java.lang.Runnable command)` Always throws a RejectedExecutionException because using this method does not make sense from either a lazy execution perspective or a cached result perspective.
`<T> java.util.List<java.util.concurrent.Future<T>>`	`invokeAll(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks)` ExecutorService requires that this method should not return until all tasks are completed, which precludes lazy execution.
`<T> java.util.List<java.util.concurrent.Future<T>>`	`invokeAll(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks, long timeout, java.util.concurrent.TimeUnit unit)` ExecutorService requires that this method should not return until all tasks are completed or the timeout expires, which precludes lazy execution.
`<T> T`	`invokeAny(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks)` Always throws a RejectedExecutionException because using this method does not make sense from either a lazy execution perspective or a cached result perspective.
`<T> T`	`invokeAny(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks, long timeout, java.util.concurrent.TimeUnit unit)` Always throws a RejectedExecutionException because using this method does not make sense from either a lazy execution perspective or a cached result perspective.
`boolean`	`isShutdown()`
`boolean`	`isTerminated()`
`void`	`shutdown()` Shuts this service down, but leaves the backing service untouched.
`java.util.List<java.lang.Runnable>`	`shutdownNow()` Trying to interpret the assumptions about the contract of this method in the light of this implementation, it seems most reasonable to take the view that all tasks are running, even if the processing has not actually started.
`<T> java.util.concurrent.Future<T>`	`submit(java.util.concurrent.Callable<T> task)`
`java.util.concurrent.Future<?>`	`submit(java.lang.Runnable command)`
`<T> java.util.concurrent.Future<T>`	`submit(java.lang.Runnable task, T result)`

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

- Constructor Detail
  - LazyExecutorService
```
public LazyExecutorService()
```
    Creates an instance using a MoreExecutors.newDirectExecutorService() for the backing service.
  - LazyExecutorService
```
public LazyExecutorService(java.util.concurrent.ExecutorService backingService)
```
    Creates an instance using the given ExecutorService as the backing service.
    The backing service will only be used to execute tasks and it may be shared by several instances or used for other purposes. Shutdowns of this instance will not shut down the backing service.
    If you shut down the backing service, this instance will be shut down automatically and all tasks submitted to this instance that have not yet been submitted to the backing service will be considered cancelled.
- Method Detail
  - shutdown
```
public void shutdown()
```
    Shuts this service down, but leaves the backing service untouched.
    
    Specified by:
    
    shutdown in interface java.util.concurrent.ExecutorService
  - shutdownNow
```
@CanIgnoreReturnValue
public java.util.List<java.lang.Runnable> shutdownNow()
```
    Trying to interpret the assumptions about the contract of this method in the light of this implementation, it seems most reasonable to take the view that all tasks are running, even if the processing has not actually started. Therefore, unfinished tasks will be cancelled and an empty list will be returned.
    
    Specified by:
    
    shutdownNow in interface java.util.concurrent.ExecutorService
  - isShutdown
```
public boolean isShutdown()
```
    Specified by:
    
    isShutdown in interface java.util.concurrent.ExecutorService
  - isTerminated
```
public boolean isTerminated()
```
    Specified by:
    
    isTerminated in interface java.util.concurrent.ExecutorService
  - awaitTermination
```
public boolean awaitTermination(long timeout,
                                java.util.concurrent.TimeUnit unit)
                         throws java.lang.InterruptedException
```
    Specified by:
    
    awaitTermination in interface java.util.concurrent.ExecutorService
    
    Throws:
    
    java.lang.InterruptedException
  - submit
```
public <T> java.util.concurrent.Future<T> submit(java.util.concurrent.Callable<T> task)
```
    Specified by:
    
    submit in interface java.util.concurrent.ExecutorService
  - submit
```
public <T> java.util.concurrent.Future<T> submit(java.lang.Runnable task,
                                                 T result)
```
    Specified by:
    
    submit in interface java.util.concurrent.ExecutorService
  - submit
```
public java.util.concurrent.Future<?> submit(java.lang.Runnable command)
```
    Specified by:
    
    submit in interface java.util.concurrent.ExecutorService
  - invokeAll
```
@CanIgnoreReturnValue
public <T> java.util.List<java.util.concurrent.Future<T>> invokeAll(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks)
                                                                                   throws java.lang.InterruptedException
```
    ExecutorService requires that this method should not return until all tasks are completed, which precludes lazy execution. Tasks are run in parallel, as far as the backing service allows.
    This method makes sense from a cached result perspective but not from a lazy execution perspective.
    
    Specified by:
    
    invokeAll in interface java.util.concurrent.ExecutorService
    
    Throws:
    
    java.lang.InterruptedException
  - invokeAll
```
@CanIgnoreReturnValue
public <T> java.util.List<java.util.concurrent.Future<T>> invokeAll(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks,
                                                                                          long timeout,
                                                                                          java.util.concurrent.TimeUnit unit)
                                                                                   throws java.lang.InterruptedException
```
    ExecutorService requires that this method should not return until all tasks are completed or the timeout expires, which precludes lazy execution. Tasks are run in parallel, as far as the backing service allows. Timeout is done as a best-effort in case of the default same thread executor.
    This method makes sense from a cached result perspective but not from a lazy execution perspective.
    
    Specified by:
    
    invokeAll in interface java.util.concurrent.ExecutorService
    
    Throws:
    
    java.lang.InterruptedException
  - invokeAny
```
public <T> T invokeAny(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks)
```
    Always throws a RejectedExecutionException because using this method does not make sense from either a lazy execution perspective or a cached result perspective.
    
    Specified by:
    
    invokeAny in interface java.util.concurrent.ExecutorService
  - invokeAny
```
public <T> T invokeAny(java.util.Collection<? extends java.util.concurrent.Callable<T>> tasks,
                       long timeout,
                       java.util.concurrent.TimeUnit unit)
```
    Always throws a RejectedExecutionException because using this method does not make sense from either a lazy execution perspective or a cached result perspective.
    
    Specified by:
    
    invokeAny in interface java.util.concurrent.ExecutorService
  - execute
```
public void execute(java.lang.Runnable command)
```
    Always throws a RejectedExecutionException because using this method does not make sense from either a lazy execution perspective or a cached result perspective.
    
    Specified by:
    
    execute in interface java.util.concurrent.Executor

Class LazyExecutorService

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

LazyExecutorService

LazyExecutorService

Method Detail

shutdown

shutdownNow

isShutdown

isTerminated

awaitTermination

submit

submit

submit

invokeAll

invokeAll

invokeAny

invokeAny

execute