Poor performance or my mistake?

[jtlapp]

I'm getting ready to do some concurrency benchmarks, but I don't think I have my Jooby app set up properly, because Spring Boot is vastly outperforming it on a REST API that does nothing but sleep for one second. In my little test run, I'm able to get 8 requests/second out of Jooby (with lots of timeouts) and 170 requests/second out of Spring (with no timeouts).

Here is my Jooby app:

package com.jtlapp.jvmvsjs;

import io.jooby.Jooby;
import io.jooby.StatusCode;
import io.jooby.netty.NettyServer;

public class JoobyNoMVCJdbcApp extends Jooby {

  {
    install(new NettyServer());

    get("/api/sleep/{millis}", ctx -> {
      int millis = ctx.path("millis").intValue();
      try {
        Thread.sleep(millis);
        return ctx.send(StatusCode.OK);
      } catch (InterruptedException e) {
        return ctx.send(StatusCode.SERVER_ERROR);
      }
    });
  }

  public static void main(final String[] args) {
    runApp(args, JoobyNoMVCJdbcApp::new);
  }
}

Here is the relevant portion of my Spring app:

package com.jtlapp.jvmvsjs.controllers;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class ApiController {

    @GetMapping("/sleep/{millis}")
    public ResponseEntity<Void> sleep(@PathVariable(name = "millis") int millis) {
        try {
            Thread.sleep(millis);
            return ResponseEntity.ok().build();
        } catch (InterruptedException e) {
            return ResponseEntity
                    .status(HttpStatus.INTERNAL_SERVER_ERROR)
                    .build();
        }
    }
}

If you need more details, they are in this repo, deploying Jooby via the jooby-nomvc-jdbc chart and Spring via the spring-jdbc-kernel chart.

What am I doing wrong?

[agentgt]

I’m guessing you are sleeping on the event loop.

I thought if you returned the ctx it would be a blocking call but I don’t use the lambda API enough to be certain.

See https://jooby.io/#responses-nonblocking

[jknack]

Hi @jtlapp,

As @agentgt suggested the issue is the sleep command, but you are NOT blocking the event loop. The default setup for a netty jooby app is:

eventloop threads:

IO_THREADS = Runtime.getRuntime().availableProcessors() * 2;

worker threads (the thread you are blocking):

WORKER_THREADS = Runtime.getRuntime().availableProcessors() * 8;

Is just too small for the kind/type of test you are running. If you still want to run the calling sleep you must provide a more suitable worker:

Something similar to Spring???

install(new NettyServer(Executors.newFixedThreadPool(200, new DefaultThreadFactory("worker"))));

More agresive:

install(new NettyServer(Executors.newCachedThreadPool(new DefaultThreadFactory("worker"))));

Spring isn't by any mean faster than Jooby 🚀

btw: The jooby link was updated in baeldung 🎉

[agentgt]

@jtlapp could also use the event loop and return a CompletableFuture that uses a single thread ScheduledExecutorService. Basically you do a supplyAsync on the Future returned from the ScheduledExecutorService.

Let me know if you need more details but I have a feeling that would run faster than manually sleeping.

EDIT this article sort of covers the technique: https://concurrencydeepdives.com/transform-future-into-completablefuture/

[jtlapp]

Thank you so much everyone for your help! I now have it working properly, and it is now scaling better than Spring Boot using Thread.sleep and virtual threads! Woo! (But yeah, I've only tested on these one-second waits so far.)

I ultimately plan for this Jooby implementation to be reactive and I'm getting there in steps. Although I have "Jdbc" in the class name, I'll be switching over to R2DBC. (FYI, I've learned that although the latest JDBC is compatible with virtual threads, it still blocks kernel threads and so does not benefit from virtual threads.)

Here's my code now:

package com.jtlapp.jvmvsjs;

import io.jooby.ExecutionMode;
import io.jooby.Jooby;
import io.jooby.ReactiveSupport;
import io.jooby.netty.NettyServer;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class JoobyNoMVCJdbcApp extends Jooby {

  {
    ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    install(new NettyServer());

    use(ReactiveSupport.concurrent());

    get("/api/sleep/{millis}", ctx -> {
      int millis = ctx.path("millis").intValue();
      var future = new CompletableFuture<String>();

      scheduler.schedule(() -> {
        future.complete("");
      }, millis, TimeUnit.MILLISECONDS);

      return future;
    });

    onStop(scheduler::shutdown);
  }

  public static void main(final String[] args) {
    runApp(args, ExecutionMode.EVENT_LOOP, JoobyNoMVCJdbcApp::new);
  }
}

P.S. Glad to hear Baeldung corrected the link!