blog/Structured Concurrency

Topic · 9 posts

Structured Concurrency

Nine posts written through a fan-out service rollout. Cancellation, timeouts, and what to do when a subtask outlives the request.

posts9

first post2026-03-22

latest2026-05-17

total read~95 min

All Project Loom Tail Latency & System Behavior

9 posts

newest first

012026-05-17
Migrating our fan-out service from Java 21 to Java 25
Most of the migration was mechanical. ShutdownOnFailure became a Joiner, throwIfFailed disappeared, and StructuredTaskScope.open replaced the constructor. Two things were not mechanical, and those are the ones worth reading.
12 min
022026-05-10
Four operational checks we run on every StructuredTaskScope
Before a fan-out service can be trusted under load, four things need to be true: outcomes counted per scope, deadlines propagated, bulkheads in place, and pinning watched in JFR. What each one looks like in code.
10 min
032026-05-04
Three structured-concurrency patterns we run in a fan-out service
Structured concurrency patterns are worth the complexity only when the cancellation policy is decided before the first fork, not after the first timeout. The three we run: aggregation on quorum, bulkheading per tenant, and a deadline shape that protects against one slow upstream.
8 min
042026-04-26
Composing resilience policies as separable layers
Resilience composition in structured concurrency comes down to one rule: keep each policy a separable layer that fires visibly in logs, or rebuild the complexity you were trying to remove.
10 min
052026-04-19
Why downstream capacity is the real ceiling on fan-out
The real ceiling on a fan-out request is downstream capacity, not the thread count. One semaphore per dependency type stops a hot path from draining the pool everyone else shares. How we set them and what changes when traffic shape shifts.
10 min
062026-04-12
Two workflow shapes that show up after fork-and-wait
Past basic fork-and-wait, two workflow shapes dominate. Streaming progress as subtasks finish works for user-facing flows. Nested scopes that mirror the service tree work for fan-out into fan-out. What each one costs.
10 min
072026-04-06
Cancelling siblings before they burn capacity
Not every failure is a timeout. A failed risk check turns the rest of the fan-out into wasted work, so the fix is to throw inside the subtask, cancelling its siblings before they burn capacity. The pattern, the implementation, and where it backfires.
10 min
082026-03-30
What a missed deadline should do, and what it should not
Timeouts in distributed code are routine, not exceptional. The real question is whether a missed deadline should fail the whole request or return what made it back in time. The three timeout shapes we run and when each one fits.
10 min
092026-03-22
What structured scopes actually catch
Most concurrency bugs in service code come from missing lifecycle, not missing parallelism. A scope that owns its forks is what makes task lifetime visible in the code that started them. The bugs that go away when scopes are right.
15 min