Thread leakage is the silent killer of “quick parallelization.” #StructuredConcurrency makes sure child tasks end with the parent scope—by design.
Learn the shutdown patterns + how they behave in failure scenarios: https://javapro.io/2026/01/28/how-to-do-structured-concurrency-in-java-25/
via @hannotify & Bram Janssens
#Concurrency bugs rarely fail loudly — they leak resources, stall requests, & waste CPU. @BalaRawool demonstrates how #StructuredConcurrency can short-circuit failures and keep workflows consistent in #SpringBoot.
Make your services more resilient: https://javapro.io/2026/02/19/virtual-threads-structured-concurrency-and-scoped-values-putting-it-all-together/
Still fighting thread pools when traffic spikes? #ProjectLoom offers a different path. @BalaRawool shows how #VirtualThreads, #StructuredConcurrency, and Scoped Values work together in a real #SpringBoot app.
See what you can simplify: https://javapro.io/2026/02/19/virtual-threads-structured-concurrency-and-scoped-values-putting-it-all-together/
Do you still need reactive programming for high throughput? @chwoerz shows how #VirtualThreads + #StructuredConcurrency handle fan-out calls cleanly and synchronously.
See the #Java25 approach & learn more: https://javapro.io/2025/12/23/java-25-getting-the-most-out-of-virtual-threads-with-structured-task-scopes-and-scoped-values/
Thread leakage is the silent killer of “quick parallelization.” #StructuredConcurrency makes sure child tasks end with the parent scope—by design.
Learn the shutdown patterns + how they behave in failure scenarios: https://javapro.io/2026/01/28/how-to-do-structured-concurrency-in-java-25/
via @hannotify & Bram Janssens
Ok, to follow up on yesterday's structured concurrency question:
In Python, I have a hypothetical HTTP client:
async with HTTP() as client:
http.get("https://site.example/index.html")
and it handles things like HTTP/2 multiplexing and connection pools and stuff. So it needs some background tasks to coordinate and maintain them.
Classically, I'd call these "daemon tasks" (after Python's daemon threads).
But I feel like I'm missing something?
#VirtualThreads scale concurrency—but they don’t fix structure or error handling. @chwoerz shows how StructuredTaskScope and ScopedValue complete the picture in #Java25. Want safer, faster concurrent code?
Still making sequential remote calls even with #VirtualThreads? @chwoerz explains how StructuredTaskScope cuts latency by running tasks concurrently—without reactive complexity. Curious how it works?
Now double at #JCON Berlin: the new #JAVAPRO issue AND our “30 Years of #Java” edition! Featuring #Java25, #VirtualThreads, #StructuredConcurrency & #GenAI.
Stop by & grab your free copies!
Can’t attend? Download or subscribe: https://javapro.io/2025/10/28/stay-updated-with-every-new-free-pdf-edition-2/
#StructuredConcurrency aims to make concurrent code readable and safe. But how does it compare to CompletableFuture? Merlin Bögershausen dives into #Java21’s latest preview features.
Deep insights + code → https://javapro.io/2025/07/22/more-action-more-overview/
Really nice #jfall talk on @quarkusio and concurrency #java #StructuredConcurrency
Nebenläufigkeit in #Java war oft mit Komplexität und Overhead verbunden. #Java21 bricht mit alten Konzepten und bringt Werkzeuge wie #StructuredConcurrency.
Lese im Artikel von Merlin Bögershausen, wie Sie damit Ihre Projekte modernisieren: https://javapro.io/de/mehr-action-mehr-uebersicht/
I’m debugging an issue, and I think the cause is a single lambda trying to read far too much data from one location at once. The details aren’t super important.
The part I’m interested in is that we do reads in a utility with concurrency X. This makes sense. Somewhere else in the codebase we do an operation with concurrency Y, which in certain cases can call this utility. In local context this is fine, but the global impact of it is that we can make up to X * Y reads simultaneously, which is bad.
I can solve the immediate problem fine. At a larger scale, what languages/libraries/patterns would prevent this? I’d like to say “use up to X concurrency here, up to Y concurrency there, but never use more than Z concurrency when reading from this specific system”.
This feels like something that #StructuredConcurrency would address? Is that the case, and are there other approaches?
#Java 21 introduces #VirtualThreads, but the real shift lies deeper: #StructuredConcurrency & Scoped Values redefine how we write parallel code. Merlin Bögershausen breaks it down — with live code examples.
Read his #JAVAPRO aritcle now → https://javapro.io/2025/07/22/more-action-more-overview/
Thanks to @kotlinweekly for publishing "Introduction to Structured Concurrency: CoroutineScope & CoroutineContext" :blobThanks:
https://mailchi.mp/kotlinweekly/kotlin-weekly-470
#kotlin #AndroidDev #tech #programming #Concurrency #StructuredConcurrency #nycdc25 #droidconNYC25
#Java 25 may redefine StructuredTaskScope before it goes final. Until then, developers face a moving target—with clear benefits & shifting syntax. Ron Veen outlines the state of #StructuredConcurrency.
In depth: https://javapro.io/2025/04/18/structured-concurrency/
Can #VirtualThreads really replace platform threads — at scale? Merlin Bögershausen examines new #Java21 #Concurrency #APIs, from StructuredTaskScope to lightweight threading.
Find out what actually changes → https://javapro.io/2025/07/22/more-action-more-overview/
#Java’s #Concurrency model has evolved: from Thread to ExecutorService to #VirtualThreads & Scoped Values. Merlin Bögershausen explains what matters in #Java21 — and why old patterns may hold you back.
Full article → https://javapro.io/2025/07/22/more-action-more-overview/
#Java now streams with memory, discards threads instead of pooling & runs without public static void main. #VirtualThreads, Gatherers & no-boilerplate coding—@ronveen breaks down the quiet revolution
#StructuredConcurrency: Hierarchical Cancellation & Error Handling
