Não consigo encontrar a diferença no uso de Mono.block() e Mono.subscribe()
Para mim, ao usar os dois métodos, o código se comporta exatamente da mesma forma. e não deveria.
Para Mono.block() minha expectativa é que um thread que o chame bloqueie e aguarde resultados, mas ainda assim é usado no método map de um Mono e basicamente se desbloqueia.
Tenho o seguinte fragmento de código usando Mono.block():
void doBlocking() {
final var myMono = Mono.just("test").map(elem -> {
System.out.printf("On thread: [%s] inside map\n",Thread.currentThread().getName());
return elem;
});
String value;
System.out.printf("On thread: [%s] before block\n",Thread.currentThread().getName());
value = myMono.block();
System.out.printf("On thread: [%s] after block\n",Thread.currentThread().getName());
System.out.println(value);
}
Quando chamo esse código, recebo o seguinte:
On thread: [main] before block
On thread: [main] inside map
On thread: [main] after block
test
Pelo que entendi, Mono.block() é um método de bloqueio, então presumo que o thread será bloqueado como seria ao adquirir um bloqueio. Mas em vez disso, o thread é usado para executar o código dentro do mapa do Mono, o que significa que ele não está bloqueado de forma alguma.
Para Mono.subscribe() eu esperaria que o thread que chama subscribe apenas continuasse e não esperasse pelos resultados, mas se comporta exatamente da mesma forma que quando usa Mono.block()
Eu tenho um fragmento semelhante, mas agora estou usando subscribe em vez de block
void doSubscribing() {
final var myMono = Mono.just("test").map(elem -> {
System.out.printf("On thread: [%s] inside map\n",Thread.currentThread().getName());
return elem;
});
AtomicReference<String> value = new AtomicReference<>();
System.out.printf("On thread: [%s] before subscribe\n",Thread.currentThread().getName());
myMono.subscribe(value::set);
System.out.printf("On thread: [%s] after subscribe\n",Thread.currentThread().getName());
System.out.println(value);
}
Quando chamo esse código novamente, estou obtendo os mesmos resultados:
On thread: [main] before subscribe
On thread: [main] inside map
On thread: [main] after subscribe
test
Eu esperaria que quando eu chamar subscribe, o thread atual continue funcionando, possivelmente exibindo:
On thread: [main] after subscribe
null
No meu caso, tanto o bloco quanto a assinatura se comportam exatamente da mesma forma, então qual é a verdadeira diferença?