Concurrency crossroads: Choosing between reactive programming and virtual threads
"Concurrency crossroads: Choosing between reactive programming and virtual threads," presented by Willem Jan Glerum (Lunatech), explores how modern Java applications handle concurrency at scale. This session was recorded at Open Community Experience 2026 (OCX26) in Brussels, Belgium.
This session compares three core approaches to concurrency in modern Java: traditional blocking models, reactive programming, and virtual threads introduced with Project Loom.
It starts by revisiting the limitations of blocking I/O, where threads remain idle while waiting for external operations such as database queries or API calls. While thread pools mitigate this to some extent, they introduce complexity around tuning and resource management, especially in cloud environments with constrained compute resources.
The session then explores reactive programming as a response to these limitations. By adopting non-blocking, event-driven models, reactive systems allow a small number of threads to handle many concurrent requests. This improves resource efficiency and throughput but introduces significant complexity in code structure, debugging, and reasoning about execution flow.
Virtual threads are presented as a newer alternative that simplifies concurrency without sacrificing scalability. By allowing lightweight, JVM-managed threads that can be cheaply created and paused, developers can return to a thread-per-request model while maintaining high performance for I/O-bound workloads.
The session also explains how virtual threads work internally through continuations, how they interact with platform threads, and what limitations still exist, including thread pinning and CPU-bound workload constraints.
Finally, the talk introduces structured concurrency as an emerging model to manage parallel tasks more safely and predictably, addressing issues such as thread leaks, cancellation strategies, and error handling.
Key topics covered
blocking I/O and thread pool limitations
reactive programming principles and trade-offs
event loop vs worker thread models
Project Loom and virtual threads
continuations and thread scheduling
thread pinning and JVM improvements
CPU-bound vs I/O-bound workloads
structured concurrency (preview)
concurrency patterns in Quarkus
performance vs complexity trade-offs
Why this matters
Concurrency isn’t just a performance problem anymore. It’s a complexity problem. Choosing the wrong model can cost you months in debugging, scaling issues, or both.
About OCX26
Open Community Experience 2026 is the Eclipse Foundation’s flagship event, held in Brussels, Belgium. It brings together developers, architects, and technical leaders to explore real-world open source technologies across AI, cloud, automotive, and more. Learn more at https://www.ocxconf.org/
Chapters
00:00 introduction to Java concurrency
02:06 blocking I/O and thread models
05:14 limitations of blocking threads
12:12 reactive programming fundamentals
13:48 event loop and non-blocking execution
16:05 reactive complexity and trade-offs
24:37 introduction to virtual threads (Project Loom)
25:33 how virtual threads work internally
30:00 thread pinning and limitations
32:00 CPU-bound vs I/O-bound considerations
38:00 structured concurrency (preview)
45:22 comparison and decision guidelines