com.github.rholder.retry

Class WaitStrategies

java.lang.Object

com.github.rholder.retry.WaitStrategies

public final class WaitStrategies
extends java.lang.Object

Factory class for instances of WaitStrategy.

Method Summary

Methods

Modifier and Type	Method and Description
static <T extends java.lang.Throwable> WaitStrategy	exceptionWait(java.lang.Class<T> exceptionClass, com.google.common.base.Function<T,java.lang.Long> function) Returns a strategy which sleeps for an amount of time based on the Exception that occurred.
static WaitStrategy	exponentialWait() Returns a strategy which sleeps for an exponential amount of time after the first failed attempt, and in exponentially incrementing amounts after each failed attempt up to Long.MAX_VALUE.
static WaitStrategy	exponentialWait(long multiplier, long maximumTime, java.util.concurrent.TimeUnit maximumTimeUnit) Returns a strategy which sleeps for an exponential amount of time after the first failed attempt, and in exponentially incrementing amounts after each failed attempt up to the maximumTime.
static WaitStrategy	exponentialWait(long maximumTime, java.util.concurrent.TimeUnit maximumTimeUnit) Returns a strategy which sleeps for an exponential amount of time after the first failed attempt, and in exponentially incrementing amounts after each failed attempt up to the maximumTime.
static WaitStrategy	fibonacciWait() Returns a strategy which sleeps for an increasing amount of time after the first failed attempt, and in Fibonacci increments after each failed attempt up to Long.MAX_VALUE.
static WaitStrategy	fibonacciWait(long multiplier, long maximumTime, java.util.concurrent.TimeUnit maximumTimeUnit) Returns a strategy which sleeps for an increasing amount of time after the first failed attempt, and in Fibonacci increments after each failed attempt up to the maximumTime.
static WaitStrategy	fibonacciWait(long maximumTime, java.util.concurrent.TimeUnit maximumTimeUnit) Returns a strategy which sleeps for an increasing amount of time after the first failed attempt, and in Fibonacci increments after each failed attempt up to the maximumTime.
static WaitStrategy	fixedWait(long sleepTime, java.util.concurrent.TimeUnit timeUnit) Returns a wait strategy that sleeps a fixed amount of time before retrying.
static WaitStrategy	incrementingWait(long initialSleepTime, java.util.concurrent.TimeUnit initialSleepTimeUnit, long increment, java.util.concurrent.TimeUnit incrementTimeUnit) Returns a strategy that sleeps a fixed amount of time after the first failed attempt and in incrementing amounts of time after each additional failed attempt.
static WaitStrategy	join(WaitStrategy... waitStrategies) Joins one or more wait strategies to derive a composite wait strategy.
static WaitStrategy	noWait() Returns a wait strategy that doesn't sleep at all before retrying.
static WaitStrategy	randomWait(long maximumTime, java.util.concurrent.TimeUnit timeUnit) Returns a strategy that sleeps a random amount of time before retrying.
static WaitStrategy	randomWait(long minimumTime, java.util.concurrent.TimeUnit minimumTimeUnit, long maximumTime, java.util.concurrent.TimeUnit maximumTimeUnit) Returns a strategy that sleeps a random amount of time before retrying.

Methods inherited from class java.lang.Object

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

Method Detail

noWait

public static WaitStrategy noWait()

Returns a wait strategy that doesn't sleep at all before retrying. Use this at your own risk.

Returns:

a wait strategy that doesn't wait between retries

fixedWait

public static WaitStrategy fixedWait(long sleepTime,
                     @Nonnull
                     java.util.concurrent.TimeUnit timeUnit)
                              throws java.lang.IllegalStateException

Returns a wait strategy that sleeps a fixed amount of time before retrying.

Parameters:

sleepTime - the time to sleep

timeUnit - the unit of the time to sleep

Returns:

a wait strategy that sleeps a fixed amount of time

Throws:

java.lang.IllegalStateException - if the sleep time is < 0

randomWait

public static WaitStrategy randomWait(long maximumTime,
                      @Nonnull
                      java.util.concurrent.TimeUnit timeUnit)

Returns a strategy that sleeps a random amount of time before retrying.

Parameters:

maximumTime - the maximum time to sleep

timeUnit - the unit of the maximum time

Returns:

a wait strategy with a random wait time

Throws:

java.lang.IllegalStateException - if the maximum sleep time is <= 0.

randomWait

public static WaitStrategy randomWait(long minimumTime,
                      @Nonnull
                      java.util.concurrent.TimeUnit minimumTimeUnit,
                      long maximumTime,
                      @Nonnull
                      java.util.concurrent.TimeUnit maximumTimeUnit)

Returns a strategy that sleeps a random amount of time before retrying.

Parameters:

minimumTime - the minimum time to sleep

minimumTimeUnit - the unit of the minimum time

maximumTime - the maximum time to sleep

maximumTimeUnit - the unit of the maximum time

Returns:

a wait strategy with a random wait time

Throws:

java.lang.IllegalStateException - if the minimum sleep time is < 0, or if the maximum sleep time is less than (or equals to) the minimum.

incrementingWait

public static WaitStrategy incrementingWait(long initialSleepTime,
                            @Nonnull
                            java.util.concurrent.TimeUnit initialSleepTimeUnit,
                            long increment,
                            @Nonnull
                            java.util.concurrent.TimeUnit incrementTimeUnit)

Returns a strategy that sleeps a fixed amount of time after the first failed attempt and in incrementing amounts of time after each additional failed attempt.

Parameters:

initialSleepTime - the time to sleep before retrying the first time

initialSleepTimeUnit - the unit of the initial sleep time

increment - the increment added to the previous sleep time after each failed attempt

incrementTimeUnit - the unit of the increment

Returns:

a wait strategy that incrementally sleeps an additional fixed time after each failed attempt

exponentialWait

public static WaitStrategy exponentialWait()

Returns a strategy which sleeps for an exponential amount of time after the first failed attempt, and in exponentially incrementing amounts after each failed attempt up to Long.MAX_VALUE.

Returns:

a wait strategy that increments with each failed attempt using exponential backoff

exponentialWait

public static WaitStrategy exponentialWait(long maximumTime,
                           @Nonnull
                           java.util.concurrent.TimeUnit maximumTimeUnit)

Returns a strategy which sleeps for an exponential amount of time after the first failed attempt, and in exponentially incrementing amounts after each failed attempt up to the maximumTime.

Parameters:

maximumTime - the maximum time to sleep

maximumTimeUnit - the unit of the maximum time

Returns:

a wait strategy that increments with each failed attempt using exponential backoff

exponentialWait

public static WaitStrategy exponentialWait(long multiplier,
                           long maximumTime,
                           @Nonnull
                           java.util.concurrent.TimeUnit maximumTimeUnit)

Returns a strategy which sleeps for an exponential amount of time after the first failed attempt, and in exponentially incrementing amounts after each failed attempt up to the maximumTime. The wait time between the retries can be controlled by the multiplier. nextWaitTime = exponentialIncrement * multiplier.

Parameters:

multiplier - multiply the wait time calculated by this

maximumTime - the maximum time to sleep

maximumTimeUnit - the unit of the maximum time

Returns:

a wait strategy that increments with each failed attempt using exponential backoff

fibonacciWait

public static WaitStrategy fibonacciWait()

Returns a strategy which sleeps for an increasing amount of time after the first failed attempt, and in Fibonacci increments after each failed attempt up to Long.MAX_VALUE.

Returns:

a wait strategy that increments with each failed attempt using a Fibonacci sequence

fibonacciWait

public static WaitStrategy fibonacciWait(long maximumTime,
                         @Nonnull
                         java.util.concurrent.TimeUnit maximumTimeUnit)

Returns a strategy which sleeps for an increasing amount of time after the first failed attempt, and in Fibonacci increments after each failed attempt up to the maximumTime.

Parameters:

maximumTime - the maximum time to sleep

maximumTimeUnit - the unit of the maximum time

Returns:

a wait strategy that increments with each failed attempt using a Fibonacci sequence

fibonacciWait

public static WaitStrategy fibonacciWait(long multiplier,
                         long maximumTime,
                         @Nonnull
                         java.util.concurrent.TimeUnit maximumTimeUnit)

Returns a strategy which sleeps for an increasing amount of time after the first failed attempt, and in Fibonacci increments after each failed attempt up to the maximumTime. The wait time between the retries can be controlled by the multiplier. nextWaitTime = fibonacciIncrement * multiplier.

Parameters:

multiplier - multiply the wait time calculated by this

maximumTime - the maximum time to sleep

maximumTimeUnit - the unit of the maximum time

Returns:

a wait strategy that increments with each failed attempt using a Fibonacci sequence

exceptionWait

public static <T extends java.lang.Throwable> WaitStrategy exceptionWait(@Nonnull
                                                         java.lang.Class<T> exceptionClass,
                                                         @Nonnull
                                                         com.google.common.base.Function<T,java.lang.Long> function)

Returns a strategy which sleeps for an amount of time based on the Exception that occurred. The function determines how the sleep time should be calculated for the given exceptionClass. If the exception does not match, a wait time of 0 is returned.

Parameters:

function - function to calculate sleep time

exceptionClass - class to calculate sleep time from

Returns:

a wait strategy calculated from the failed attempt

join

public static WaitStrategy join(WaitStrategy... waitStrategies)

Joins one or more wait strategies to derive a composite wait strategy. The new joined strategy will have a wait time which is total of all wait times computed one after another in order.

Parameters:

waitStrategies - Wait strategies that need to be applied one after another for computing the sleep time.

Returns:

A composite wait strategy