All Classes and Interfaces

Class
Description
Assertion utilities.
Allows asynchronous executions to record their results or complete an execution.
AsyncExecution and AsyncExecutionInternal implementation.
Internal async execution APIs.
A Runnable that manually triggers asynchronous retries or completion via an asynchronous execution.
A Supplier that manually triggers asynchronous retries or completion via an asynchronous execution.
A bulkhead allows you to restrict concurrent executions as a way of preventing system overload.
Builds Bulkhead instances.
Configuration for a Bulkhead.
A PolicyExecutor that handles failures according to a Bulkhead.
Thrown when an execution is attempted against a Bulkhead that is full.
A Bulkhead implementation that supports sync and async waiting.
A rate limiter implementation that allows bursts of executions, up to the max permits per period.
A call that can perform Failsafe executions and can be cancelled.
A call implementation that delegates to an execution.
A BiPredicate that throws checked exceptions.
A Consumer that throws checked exceptions.
A Function that throws checked exceptions.
A Predicate that throws checked exceptions.
A Runnable that throws checked exceptions.
A Supplier that throws checked exceptions.
A circuit breaker temporarily blocks execution when a configured number of failures are exceeded.
The state of the circuit.
Builds CircuitBreaker instances.
Configuration for a CircuitBreaker.
A PolicyExecutor that handles failures according to a CircuitBreaker.
A CircuitBreaker implementation.
Thrown when an execution is attempted against a CircuitBreaker that is open.
Indicates a circuit breaker's state changed.
The state of a circuit.
Stats for a circuit breaker.
 
A Runnable that provides execution context.
A Supplier that provides execution context.
A CircuitStats implementation that counts execution results using a BitSet.
A default CircuitStats implementation that tracks a single execution result.
A default ScheduledFuture implementation.
A policy that can be delayed between executions.
A builder of policies that can be delayed between executions.
Configuration for policies that can delay between executions.
A Scheduler implementation that schedules delays on an internal, common ScheduledExecutorService and executes tasks on either a provided ExecutorService, ForkJoinPool.commonPool(), or an internal ForkJoinPool instance.
 
 
Duration and long utilities.
Internal handling of events.
Listens for events.
Tracks synchronous executions and handles failures according to one or more policies.
Indicates an execution was attempted.
Indicates an execution was completed or cancelled.
Contextual execution information.
Encapsulates information about a Failsafe execution.
Execution and ExecutionInternal implementation.
Internal execution APIs.
This class represents the internal result of an execution attempt for zero or more policies, before or after the policy has handled the result.
Indicates an execution was scheduled.
Simple, sophisticated failure handling.
Thrown when a synchronous Failsafe execution fails with an Exception, wrapping the underlying exception.
An executor that handles failures according to configured policies.
A CompletableFuture implementation that propagates cancellations and calls completion handlers.
A policy that can handle specifically configured failures.
A Policy that allows configurable conditions to determine whether an execution is a failure.
Configuration for policies that handle specific failures and conditions.
A Policy that handles failures using a fallback function or result.
Builds Fallback instances.
Configuration for a Fallback.
A PolicyExecutor that handles failures according to a Fallback.
A Fallback implementation.
Utilities for creating and applying Failsafe executable functions.
A LinkedList of CompletableFutures that removes a future from the list when it's completed.
 
 
List utilities.
Misc math utilities.
 
A policy for handling executions.
Builds policies.
Configuration for a Policy.
Handles execution and execution results according to a policy.
Configures listeners for a policy execution result.
Utilities for computing random delays.
A rate limiter allows you to control the rate of executions as a way of preventing system overload.
Builds RateLimiter instances.
Configuration for a RateLimiter.
A PolicyExecutor that handles failures according to a RateLimiter.
A RateLimiter implementation that supports smooth and bursty rate limiting.
 
 
Thrown when an execution exceeds or would exceed a RateLimiter.
A policy that defines when retries should be performed.
Builds RetryPolicy instances.
Configuration for a RetryPolicy.
A PolicyExecutor that handles failures according to a RetryPolicy.
A RetryPolicy implementation.
Schedules executions.
A rate limiter implementation that evenly distributes permits over time, based on the max permits per period.
SyncExecution and SyncExecutionInternal implementation.
Internal execution APIs.
A CircuitStats implementation that counts execution results within a time period, and buckets results to minimize overhead.
 
 
 
A policy that cancels and fails an excecution with a TimeoutExceededException if a timeout is exceeded.
Builds Timeout instances.
Configuration for a Timeout.
Thrown when an execution exceeds a configured Timeout.
A PolicyExecutor that handles failures according to a Timeout.
A Timeout implementation.