Is cancellation supported when invalidating while expensive computation is queued/running?

[henryju]

Hi,

I am considering using Caffeine in my application as a replacement for a home-made feature. I am not too much interested by the cache eviction features, but more by the concurrent async loading from expensive operations.

For my use case, I would like to be able to cancel the queued/running expensive operation after receiving some event telling that the computation inputs might be outdated (I say "might", because we don't really know what input was used by the computation job, as it is async).

Something like:

Thread1:

CompletableFuture<X> future = asyncCache.get("key");
var result = future.get();

Thread2 (while thread 1 is blocked on the future.get() )

asyncCache.invalidate("key");

Will a call to invalidate cancel the CompletableFuture previously obtained?

In fact, what would really allow me to replace my current component would be if the asyncCache would be able to "substitute" the CompletableFuture so that it ultimately completes with a second call to the expensive operation. From Thread1 point of view, it would be totally transparent.

Is that possible?

[ben-manes]

It is best to think of Caffeine as a ConcurrentHashMap with lifecycle policies, where async cache is a Map<K, CompletableFuture<V>>.

I would like to be able to cancel the queued/running expensive operation

Note that CompletableFuture#cancel does not send an interrupt signal to the underlying thread, and merely terminates the future and its dependents as canceled. If the expensive operation has not yet started then it won't, but if it has then it will continue unabated.

Will a call to invalidate cancel the CompletableFuture previously obtained?

Nope, it is the same as Map.remove. You could use the asMap() to remove and obtain the previous value to call cancel() yourself. A future that is canceled, completed exceptionally, or completes with null are automatically removed from the cache using a dependent action.

if the asyncCache would be able to "substitute" the CompletableFuture so that it ultimately completes with a second call to the expensive operation.

The cache always returns the future it was given by the loader and does not provide any proxy. This is because operations like cancel don't propagate upstream and the lack of equality means that atomic action like replace(key, value) might otherwise not match.

Is that possible?

It sounds like you probably want something custom.

[henryju]

Thanks a lot for your answers, this is very useful.

[ben-manes]

It’s probably too late, but failsafe async retry policy might have helped you here. That would be a transparent retry if the old future was canceled.