This blog post explains it quite well:
https://www.nurkiewicz.com/2015/03/completablefuture-cant-be-interrupted.html?m=1

This flag only works when you use TimeLimiter to decorate a method which returns a Future. But unfortunately Futures are not yet supported via annotations/aspects, but only via the functional style.

This flag only works when you use TimeLimiter to decorate a method which returns a Future.

Is there a code example for this? This did not work for me, the Thread was not interrupted:

public Callable<List<String>> getAll() {
    TimeLimiterConfig config = TimeLimiterConfig.custom().cancelRunningFuture(true).timeoutDuration(Duration.ofMillis(1000)).build();
    TimeLimiterRegistry timeLimiterRegistry = TimeLimiterRegistry.of(config);
    ExecutorService executor = Executors.newSingleThreadExecutor();
	
    return timeLimiterRegistry.timeLimiter("getAll").decorateFutureSupplier(() -> executor.submit(() -> repository.getAll()));
}

@RobWin I'm trying to understand this, but I struggle with the following:

• I tried the @TimeLimiter-Annotation on a method simply returning an object/String/whatever --> I get an error that the TimeLimiter-Annotation needs a future return type --> fine with me

• on the other hand you mention, that the @TimeLimiter-Annotation cannot cancel running CompletableFutures and therefore doesn't work as expected

So what return-type do I need for the @TimeLimiter-Annotation to work as expected (cancel running execution and throw TimeoutException)?

We had a running functional implementation, but we are trying to switch away from this to an annotation-based style. Simply because we want to get rid of the gluecode (decorating suppliers...).

Hi @SidekickJohn

You can use a TimeLimiter to decorate a method which returns a Future. A future can be canceled.
But unfortunately Futures are not yet supported via annotations/aspects, but only via the functional style.
We tried to implement it, but supporting Future for TimeLimiter, Retry, Bulkhead, CircuitBreaker via annotations caused us some headaches.

@RobWin thanks for clarifying.

Just to make sure I understood you correctly:
Doesnt't that actually mean that there is currently no way to make the @TimeLimiter-Annotation work? No matter what return-type I would choose, the annotation would not work --> correct?

No, TimeLimiter (TimeLimiterAspect) still throws a TimeoutException. See our Spring Boot 2 demo.
But TimeLimiter cannot cancel a CompletableFuture. Otherwise we would have to implement our own CompletableFuture, but that is too cumbersome to maintain.

The TimeLimiter also works for all reactive types from Spring Reactor or RxJava2 and RxJava3

Ah alright, now I get it. Thank you.

The TimeoutException is thrown, but the CompletableFuture is still running.

In this case: would you expect a @Retry-Annotation which has the TimeoutException configured as a retryException to take action?

Example:

@TimeLimiter(name="myName")
@Retry(name="myName)
public CompletableFuture<String> myFuncition() {...}

Yes, check out our demo:

https://github.com/resilience4j/resilience4j-spring-boot2-demo/blob/master/src/main/java/io/github/robwin/service/BackendAService.java#L141-L148

You can add a @Retry.

Hello! Thank you for explanation for this issue. I'd like to clarify my understanding.

I need to use a ThreadPoolBulkhead combined with CircuitBreaker and TimeLimiter, something like example from docs

CompletableFuture<String> future = Decorators.ofSupplier(supplier)
    .withThreadPoolBulkhead(threadPoolBulkhead)
    .withTimeLimiter(timeLimiter, scheduledExecutorService)
    .withCircuitBreaker(circuitBreaker)
    .withFallback(asList(TimeoutException.class, 
                         CallNotPermittedException.class, 
                         BulkheadFullException.class),  
                  throwable -> "Hello from Recovery")
    .get().toCompletableFuture();

So, in this case (because of CompletableFuture) I cannot use interrupting of ThreadPoolBulkhead's thread by timeout. Is there some way to use ThreadPoolBulkhead + TimeLimiter with ability to interrupt a thread, for example using ThreadPoolBulkhead with simple Future instead of CompletableFuture?

As I know I could do it in hystrix. It needed to prevent threads from freezing for a long time when many timeouts occur

Unfortunately the ThreadPoolBulkhead always returns a CompletionStage backed by a CompletableFuture.
You can only combine an ExecutorService and TimeLimniter:

        ExecutorService executor = Executors.newFixedThreadPool(10);
        timeLimiter.executeFutureSupplier(() -> executor.submit(callable)

OK, thank you. Are there some plans to support it in thread pool bulhkead in future for compatibility of migrating from hystrix?

No, currently there are no plans to support Future since blocking code should be prevented.
We also do not strive for compatibility to Hystrix.

OK, if I understand correctly, to use TimeLimiter with interruptable thread pool I can use ExecutorService instead of ThreadPoolBulkhead with almost same features (core threads, max threads, keepAliveTime, intercepting cases when there are no free workers), and I have to implement getting thread pool by name using ConcurrentHashMap directly instead of ThreadPoolBulkheadRegistry?

If you like you can try to create a PR and add a <T> Future<T> submit(Callable<T> task) and Supplier<Future<T>> decorateCallable(...) method to the ThreadPoolBulkhead interface.

Shouldn't be too complicated and then we can support ThreadPoolBulkhead and Timelimiter.

@RobWin
"@Timelimiter times out slow method but does not cancel running future" any additions made for this?