Timeouts in structured concurrency

[David Alayachew]

For 1, the javadoc absolutely does help you. Please read for open.

https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/util/concurrent/StructuredTaskScope.html#open()

As for verbose, can you go into more detail? This is a traditional builder
pattern addition, so it is literally 1 static method call.

That said, if you dislike a 0 parameter call being forced into being a 2
paramefer call when you need to add timeout, then sure, I think adding an
overload for that static method that takes in the configFunction is
reasonable. I'd support that.


On Thu, Dec 18, 2025, 3:46 PM Holo The Sage Wolf <holo3146 at gmail.com> wrote:

> Hello Loom devs,
> Few years ago I experimented in a personal PoC project with
> StructuredConcurrency in Java 19 and I had to stop working on it for
> personal reasons.
>
> Recently I came back to the project and updated it to Java 25 and had to
> change my code to the new way the API is built and while doing that I
> noticed a couple of stuff I want to point out:
>
> 1. The default Joiner method can't receive timeout
> Obviously that is wrong, but the API and JavaDoc don't actually help you.
> Say you start with:
>  ```java
> try (var scope =  StructuredTaskScope.open()) {
>     ...
> }
> ```
> And I want to evolve the code to add timeout, I look at
> the StructuredTaskScope static methods, and won't see any way to do that.
> After reading a bit what StructuredTaskScope.open(Joiner, configFunction)
> does, I will realise that I can set the timeout using the configFunction.
> But then I will encounter the problem that I need to provide a Joiner,
> currently the only way to actually get the "no args method"-joiner is to
> look at the source code of the method, see which Joiner it uses and copy
> that into my method to get:
>  ```java
> try (var scope =
> StructuredTaskScope.open(Joiner.awaitAllSuccessfulOrThrow(), (conf) ->
> ...)) {
>     ...
> }
> ```
> Not only is this a lot of work to do something very simple, there is a
> high chance that people who start learning concurrency will want to use
> timeout before they even know what the Joiner object is.
>
> 2. Changing only the timeout is "verbose".
> I can only talk from my experience, so I may have the wrong impression,
> but I feel like setting timeout is orders of magnitude more common than
> changing the default ThreadFactory (especially when using virtual threads)
> or setting a name.
> I feel like adding a couple of overloads of the open method that takes
> only an extra parameter of duration will be convenient:
> > StructuredTaskScope.open()
> > StructuredTaskScope.open(Duration timeout)
> > StructuredTaskScope.open(Joiner joiner)
> > StructuredTaskScope.open(Joiner joiner, Duration timeout)
> > StructuredTaskScope.open(Joiner joiner, Function<Configuration,
> Configuration> configFunction)
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://mail.openjdk.org/pipermail/loom-dev/attachments/20251218/aa7dc762/attachment.htm>