Tech › JVM
8 posts
The final part of the JVM concurrency series. A four-question framework for choosing between Virtual Thread, Reactor, and Coroutines, plus the unique strengths of each technology and the most common misconceptions.
How virtual thread mount/unmount works under the hood, how it differs from coroutine continuations, why AOP proxies just work, and the synchronized pinning trap with practical fixes.
How Spring wraps suspend fun in mono {} to run it on the Reactor pipeline, and the structural limit where AOP proxies mistake COROUTINE_SUSPENDED for method completion — including why @Transactional + coroutines does not work.
Writing Reactor-style deep flatMap chains as sequential, synchronous-looking code with Kotlin Coroutines. Covers suspend, CPS transformation, state machines, Flow, Channel, and structured concurrency.
Starting from the one-request-one-thread limit of Spring MVC, this post digs into how WebFlux actually works — the Netty event loop architecture, MVC vs WebFlux request handling, and what you must never do on an event loop thread.
From the Pull vs Push model to the four Reactive Streams interfaces, Reactor's Mono/Flux and core operators, and backpressure — building a solid mental model of reactive programming.
From Thread and Runnable to Callable/Future, ExecutorService, and CompletableFuture — tracing how Java's concurrency API evolved toward "stop managing threads yourself."
The difference between processes and threads, concurrency vs parallelism, and why synchronous/asynchronous and blocking/non-blocking are two independent axes — foundational concepts for the JVM concurrency series.