Mono.defer() 的实际情况是什么？

Question

I know what Mono.defer() does do, but when should I use it? I know that one of the use cases is to defer some blocking side effects in functions that return Mono , but that's generally a bad practice (putting side effects in functions that return Mono or Flux ). And when I want to wrap some blocking code within the Mono there's Mono.fromCallable() . So what is the best case to use Mono.defer() ?

Answer 1

Mono.fromCallable() is for regular deferred service call. The Mono.defer() produces a Mono and it does that only when you subscribe . So, you may decide to create this or that Mono not during composition phase, but exactly on the target subscribe.

Answer 2

@a.khakh

A very simple use case that helped me was to execute blocking code in another thread, that is, to process that blocking call so that the main-thread would not block me.

I saw the need to use defer to subscribe in another thread, in this case in a Scheduler provided by project reactor and programmed by Simon Basle.

• source using Mono.defer

If you do a combination of defer plus subscribeOn and a Schedulers.boundedElastic you will make your code non-blocking or rather it will not block your application, removing contention from the main-thread.

---

The following image shows that the third component of a Combo, internally uses a defer plus a Scheduler, so as not to block the application.

• ignore the method called ui.access() it is part of the vaadin framework.

Mono.defer(()  -> this.reactiveRandomNumbers.monoFrecuency(event.getValue().getSize())) <1>
                        .doOnEach(signal -> log.info("Thread name doOnNext(): {}", Thread.currentThread().getName()))
                        .subscribeOn(Schedulers.boundedElastic())
                        .subscribe(subscribeMap -> {
                            ui.access(() -> {
                                log.info("Thread name subscribe(): {}", Thread.currentThread().getName());
                                this.execute(event.getValue().getSize(), e -> subscribeMap);
                            });
                        });

Answer 3

Sometimes you need to calculate something synchronous lazily.

For instance, we have an asynchronous service

public interface SomeService {

    Mono<User> getUserByName(String name);

    Mono<CreateUserResult> createUser(User user);

}

and an endpoint, which looks up for the user in this service and creates if the one was not found. BUT before the creation some heavy calculations must be performed in sync in special thread pool. So

someService.getUserByName(name)
                .switchIfEmpty(Mono.defer(() -> {
                    var someHeavyCalculatedData = localHeavyService.doSomethingNecessary(name);
                    return someService.createUser(new User(name, someHeavyCalculatedData));
                }).subscribeOn(specialScheduler));

Sure, you can say that we can use Mono.fromCallable instead and do it like

someService.getUserByName(name)
                .switchIfEmpty(Mono.fromCallable(() -> localHeavyService.doSomethingNecessary(name))
                        .subscribeOn(specialScheduler)
                        .flatMap(someHeavyCalculatedData -> someService.createUser(new User(name, someHeavyCalculatedData)))
                );

But each method call in reactive chain causes creation of a huge amount of objects in memory. Well for one single call you, probably won't notice anything, but with higher load frequent allocating memory, then releasing it by GC would cause your app being slow.