AsyncTimeout (SmallRye Fault Tolerance: Core 5.1.0 API)

java.lang.Object
- io.smallrye.faulttolerance.core.timeout.AsyncTimeout<V>

All Implemented Interfaces:

FaultToleranceStrategy<Future<V>>
```
public class AsyncTimeout<V>
extends Object
implements FaultToleranceStrategy<Future<V>>
```
The next strategy in the chain must be Timeout, and it is invoked on an extra thread. Communication then happens using AsyncTimeoutNotification.
Note that the TimeoutException thrown from this strategy might come from two places: the Timeout strategy throwing, or AsyncTimeoutTask#timedOut setting an exception as a result of AsyncTimeoutNotification. Both might happen, and whichever happens first gets to decide.

Constructor Summary

Constructors
Constructor Description

AsyncTimeout(Timeout<Future<V>> delegate, Executor executor)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`Future<V>`	`apply(InvocationContext<Future<V>> ctx)`	Apply the fault tolerance strategy around the target `Callable`.

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

- Constructor Detail
  - AsyncTimeout
```
public AsyncTimeout(Timeout<Future<V>> delegate,
                    Executor executor)
```
- Method Detail
  - apply
```
public Future<V> apply(InvocationContext<Future<V>> ctx)
                throws Exception
```
    Description copied from interface: FaultToleranceStrategy
    
    Apply the fault tolerance strategy around the target Callable. The Callable is wrapped in an InvocationContext.
    
    Specified by:
    
    apply in interface FaultToleranceStrategy<V>
    
    Parameters:
    
    ctx - the InvocationContext wrapping the Callable guarded by this fault tolerance strategy
    
    Returns:
    
    result computed by the target Callable
    
    Throws:
    
    Exception - if result couldn't be computed