org.apache.river.thread

Class SynchronousExecutors.Task<T>

java.lang.Object

org.apache.river.thread.SynchronousExecutors.Task<T>

All Implemented Interfaces:

Comparable<SynchronousExecutors.Task>, java.util.concurrent.Callable<T>, java.util.concurrent.Future<T>

Enclosing class:

SynchronousExecutors

private static class SynchronousExecutors.Task<T>
extends Object
implements java.util.concurrent.Callable<T>, java.util.concurrent.Future<T>, Comparable<SynchronousExecutors.Task>

Field Summary

Fields

Modifier and Type	Field and Description
private int	attempt
(package private) boolean	cancelled
private boolean	comparable
(package private) boolean	complete
private static long[]	delays Default delay backoff times.
(package private) Exception	exception
private java.util.concurrent.locks.Lock	executorLock
(package private) Thread	executorThread
private SynchronousExecutors.QueueWrapper	queue
(package private) T	result
private java.util.concurrent.locks.Condition	resultAwait
private long	retryTime
private java.util.concurrent.Callable<T>	task
private java.util.concurrent.locks.Condition	waiting

Constructor Summary

Constructors

Constructor and Description
Task(java.util.concurrent.Callable<T> c, SynchronousExecutors.QueueWrapper wrapper, java.util.concurrent.locks.Lock executorLock, java.util.concurrent.locks.Condition distributorWaiting)

Method Summary

Modifier and Type	Method and Description
T	call()
boolean	cancel(boolean mayInterruptIfRunning)
int	compareTo(SynchronousExecutors.Task o)
(package private) long	delay() Return the next time at which we should make another attempt.
T	get()
T	get(long timeout, java.util.concurrent.TimeUnit unit)
boolean	isCancelled()
boolean	isDone()

Methods inherited from class java.lang.Object

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

Field Detail

delays

private static final long[] delays

Default delay backoff times.

See Also:

retryTime

complete

volatile boolean complete

cancelled

volatile boolean cancelled

result

volatile T result

exception

volatile Exception exception

executorThread

volatile Thread executorThread

task

private final java.util.concurrent.Callable<T> task

queue

private final SynchronousExecutors.QueueWrapper queue

executorLock

private final java.util.concurrent.locks.Lock executorLock

waiting

private final java.util.concurrent.locks.Condition waiting

resultAwait

private final java.util.concurrent.locks.Condition resultAwait

comparable

private final boolean comparable

attempt

private int attempt

retryTime

private volatile long retryTime

Constructor Detail

Task

Task(java.util.concurrent.Callable<T> c,
     SynchronousExecutors.QueueWrapper wrapper,
     java.util.concurrent.locks.Lock executorLock,
     java.util.concurrent.locks.Condition distributorWaiting)

Method Detail

delay

long delay()

Return the next time at which we should make another attempt. This is not an interval, but the actual time.

The implementation is free to do as it pleases with the policy here. The default implementation is to delay using intervals of 1 second, 5 seconds, 10 seconds, and 1 minute between attempts, and then retrying every five minutes forever.

The default implementation assumes it is being called from the default run method and that the current thread holds the lock on this object. If the caller does not own the lock the result is undefined and could result in an exception.

call

public T call()
       throws Exception

Specified by:

call in interface java.util.concurrent.Callable<T>

Throws:

Exception

cancel

public boolean cancel(boolean mayInterruptIfRunning)

Specified by:

cancel in interface java.util.concurrent.Future<T>

isCancelled

public boolean isCancelled()

Specified by:

isCancelled in interface java.util.concurrent.Future<T>

isDone

public boolean isDone()

Specified by:

isDone in interface java.util.concurrent.Future<T>

get

public T get()
      throws InterruptedException,
             java.util.concurrent.ExecutionException

Specified by:

get in interface java.util.concurrent.Future<T>

Throws:

InterruptedException

java.util.concurrent.ExecutionException

get

public T get(long timeout,
             java.util.concurrent.TimeUnit unit)
      throws InterruptedException,
             java.util.concurrent.ExecutionException,
             java.util.concurrent.TimeoutException

Specified by:

get in interface java.util.concurrent.Future<T>

Throws:

InterruptedException

java.util.concurrent.ExecutionException

java.util.concurrent.TimeoutException

compareTo

public int compareTo(SynchronousExecutors.Task o)

Specified by:

compareTo in interface Comparable<SynchronousExecutors.Task>