loom VS BlockHound

It's more accurate to say Loom is [a particular type of] continuations in the JVM, which can be used to implement green threads / fibers.

You can see the implementation of VirtualThread here: https://github.com/openjdk/loom/blob/fibers/src/java.base/sh...

This uses the internal 'one-shot delimited continuation': https://github.com/openjdk/loom/blob/fibers/src/java.base/sh...

So, at least in principle, there is scope for other styles of concurrency to be implemented over this.

Loom is actively developed https://github.com/openjdk/loom

Currently the Thread public constructor defaults to platform threads to be fully backwards compatible. So all libraries must be updated to support the new model.

[1] https://github.com/openjdk/loom/blob/fibers/src/java.base/share/classes/java/lang/VirtualThread.java#L933

There is a great tool called Blockhound we can use to detect if/when we have a blocking call in our application. This way, we can ensure that we don't break the non-blocking nature of our application by mistake while developing new features. Setting it up is fairly straightforward.

There's even a test library to detect them: https://github.com/reactor/BlockHound

One of the talks in my current portfolio is Migrating from Imperative to Reactive. The talk is based on a demo migrating from Spring WebMVC to Spring WebFlux in a step-by-step approach. One of the steps involves installing BlockHound: it allows to check whether a blocking call occurs in a thread it shouldn't happen and throws an exception at runtime when it happens.

The first step is to make the application compatible with GraalVM. We need to remove Blockhound from the code. Blockhound allows verifying that no blocking code runs in unwanted places. It's a Java agent that requires a JDK, not a JRE. It's great for a demo, but it has nothing to do with a production application.