What's the advantage of using Spring Async vs. Just returning the CompletableFuture
on your own?
The @EnableAsync annotation switches on Spring's ability to run @Async methods in a background thread pool. This class also customizes the Executor by defining a new bean. Here, the method is named taskExecutor , since this is the specific method name for which Spring searches.
Simply put, annotating a method of a bean with @Async will make it execute in a separate thread. In other words, the caller will not wait for the completion of the called method. One interesting aspect in Spring is that the event support in the framework also has support for async processing if necessary.
Never use @Async on top of a private method. In runtime, it will not able to create a proxy and, therefore, not work.
There is no “vs.” between the two – these are complementary technologies:
CompletableFuture
provides a convenient way to chain different stages of asynchronous computation – with more flexibility than Spring's ListenableFuture
;@Async
provides convenient management of your background tasks and threads, with standard Spring configuration for your executor(s).But both can be combined (since Spring 4.2). Suppose you want to turn the following method into a background task returning a CompletableFuture
:
public String compute() {
// do something slow
return "my result";
}
What you have to do:
@EnableAsync
and an Executor
bean@Async
CompletableFuture.completedFuture()
@Async
public CompletableFuture<String> computeAsync() {
// do something slow - no change to this part
// note: no need to wrap your code in a lambda/method reference,
// no need to bother about executor handling
return CompletableFuture.completedFuture("my result");
}
As you notice, you don't have to bother about submitting the background task to an executor: Spring takes care of that for you. You only have to wrap the result into into a completed CompletableFuture
so that the signature matches what the caller expects.
In fact, this is equivalent to:
@Autowire
private Executor executor;
public CompletableFuture<String> computeAsync() {
return CompletableFuture.supplyAsync(() -> {
// do something slow
return "my result";
}, executor);
}
but it removes the need to:
supplyAsync()
callYour application is managed by the container. Since it's discouraged to spawn Thread
s on you own, you can let the container inject a managed Executor
.
@Service
class MyService {
@Autowired
private Executor executor;
public CompletableFuture<?> compute() {
return CompletableFuture.supplyAsync(() -> /* compute value */, executor);
}
}
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With