com.google.cloud.hadoop.util

Class LazyExecutorService

java.lang.Object

com.google.cloud.hadoop.util.LazyExecutorService

All Implemented Interfaces:

Executor, ExecutorService

@GwtIncompatible
public final class LazyExecutorService
extends Object
implements 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(ExecutorService backingService) Creates an instance using the given ExecutorService as the backing service.

Method Summary

Modifier and Type	Method and Description
boolean	awaitTermination(long timeout, TimeUnit unit)
void	execute(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> List<Future<T>>	invokeAll(Collection<? extends Callable<T>> tasks) ExecutorService requires that this method should not return until all tasks are completed, which precludes lazy execution.
<T> List<Future<T>>	invokeAll(Collection<? extends Callable<T>> tasks, long timeout, 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(Collection<? extends 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(Collection<? extends Callable<T>> tasks, long timeout, 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.
List<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> Future<T>	submit(Callable<T> task)
Future<?>	submit(Runnable command)
<T> Future<T>	submit(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(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 ExecutorService

shutdownNow

@CanIgnoreReturnValue
public List<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 ExecutorService

isShutdown

public boolean isShutdown()

Specified by:

isShutdown in interface ExecutorService

isTerminated

public boolean isTerminated()

Specified by:

isTerminated in interface ExecutorService

awaitTermination

public boolean awaitTermination(long timeout,
                                TimeUnit unit)
                         throws InterruptedException

Specified by:

awaitTermination in interface ExecutorService

Throws:

InterruptedException

submit

public <T> Future<T> submit(Callable<T> task)

Specified by:

submit in interface ExecutorService

submit

public <T> Future<T> submit(Runnable task,
                            T result)

Specified by:

submit in interface ExecutorService

submit

public Future<?> submit(Runnable command)

Specified by:

submit in interface ExecutorService

invokeAll

@CanIgnoreReturnValue
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
                                                    throws 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 ExecutorService

Throws:

InterruptedException

invokeAll

@CanIgnoreReturnValue
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                                           long timeout,
                                                           TimeUnit unit)
                                                    throws 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 ExecutorService

Throws:

InterruptedException

invokeAny

public <T> T invokeAny(Collection<? extends 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 ExecutorService

invokeAny

public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                       long timeout,
                       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 ExecutorService

execute

public void execute(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 Executor