How can I turn blocking code into a responsive style?

Question

I have always been used to blocking programming and working in the Spring MVC framework. Recently, I considered learning reactive programming. I was full of doubts about how to convert the previous logic into a new style.

See the following processing(Pseudocode):

public Mono<List<String>> a() {
    // 1...
    List<String> strings = new ArrayList<>();
    for (int i = 0; i < 100; i++) {
        strings.add("hello " + i);
    }
    Mono<List<String>> mono = Mono.just(strings);
    // 2...
    mono.subscribe(e -> {
        b();
    });
    // 3...
    mono.subscribe(e -> {
        c();
    });
    mono.subscribeOn(Schedulers.boundedElastic());
    return mono;
}

// Simulate a time-consuming process.
public void b() {
    try {
        Thread.sleep(100);
    } catch (InterruptedException err) {
        throw new RuntimeException(err);
    }
}

// Simulate the process of requesting an external HTTP interface once.
public int c() {
    try {
        Thread.sleep(300);
    } catch (InterruptedException err) {
        throw new RuntimeException(err);
    }
    return 1;
}

I tried to convert it into code that conforms to the responsive programming style, but found that the time-consuming code logic has blocked the current thread, which is inconsistent with my expectation.

I tested Webflux and Tomcat respectively, and the results show that the performance of the former is very poor. I suspect that the IO thread is blocked, which can be seen from the thread sleep time.

Ideally, you would simulate delays with `Mono.delay`. – Khepu Nov 06 '22 at 15:44 — Khepu, Nov 06 '22 at 15:44

Karol Dowbecki · Answer 1 · 2022-11-05T18:16:45.130

2

Thread.sleep() will pause the JVM thread running the request. You can't call this method with a Spring WebFlux application. By design WebFlux uses very few threads to handle the requests to avoid context switching but if your code intentionally blocks them you break the whole design.

In practice Spring WebFlux can be faster than a regular Spring MVC if the application workload is I/O bound e.g. a micro-service that calls multiple external APIs and doesn't perform significant calculations.

I'd suggest that you try simulating the I/O operations by making a network call to an actual server using a reactive library like Reactor Netty. Otherwise you would have to dig into the code and figure out how to create a meaningful mock for a network I/O operation, which might be tricky.

edited Nov 05 '22 at 18:16

answered Nov 05 '22 at 18:10

Karol Dowbecki

43,645
9
78
111

Shouldn't looping some thousand times be enough for a simulation? Something like `for(int i = 0; i < 10000; i++) {}`. I'm also interested in learning the reactive way of things. – Jetto Martínez Nov 05 '22 at 18:17
1

Your example `for` loop might be optimized away by JVM because it has no side-effects. I'd suggest to instead implement a simple Spring Boot app with a @Controller that calls 3-5 URLs. Do one with MVC and RestTemplate and second with WebFlux and WebClient. Than deploy and compare how the application scales when you do 100+ TPS. – Karol Dowbecki Nov 05 '22 at 18:21

score 0 · Answer 2 · answered Nov 05 '22 at 18:23

Reactive programming is good for juggling work across threads when "someone else other than this JVM" is busy.

So, handover to OS for file write, or to DB for record update or to another remote server over API call. Let them call you back when they have the result. Eventually, you should be juggling, but work goes on somewhere else and results flow in. This is where reactivity shines.

So, it's difficult to simulate with Thread.sleep or for loop running 10_000 times.

Also, it means the whole flow has to be reactive - your disk IO library should be reactive, your DB library should be reactive, your Rest client for calling other networked services should be reactive. Reactor should be helping with solutions for each of these.

Also, its not all-or-nothing. Even if your disk IO is blocking, you will still gain benefits if atleast the Rest client is non-blocking.

Do you think the way to simulate blocking is incorrect? I think I'll try it as you say, thank you for your reply! — Terrence, Nov 06 '22 at 09:59

How can I turn blocking code into a responsive style?

2 Answers2