Java结构化并发中如何在超时场景下获取部分结果？

这个问题我之前做并发任务时也踩过坑！你遇到的IllegalStateException本质是结构化并发的安全约束在起作用——StructuredTaskScope要求主线程（Owner）必须对所有子任务的生命周期负责到底：要么等它们全部完成，要么主动取消未完成的任务，否则框架会认为你可能遗漏了资源清理，直接抛出异常阻止你获取结果。

先分析你原代码的问题 #

你调用scope.joinUntil(2000ms)超时后，subtask2其实已经成功完成了，但此时StructuredTaskScope的内部状态还是「未完成join」，主线程还没履行完对所有子任务的管理责任。这时候调用subtask.get()会触发框架的检查，直接抛出你看到的Owner did not join after forking subtasks异常。

而且更隐蔽的是：就算你不调用get()，当try-with-resources块退出时，scope.close()也会检查所有子任务的状态，发现有未完成/未取消的子任务，照样会抛出异常。

正确的解决思路：先收尾，再拿结果 #

超时后，我们需要先主动取消未完成的子任务，再等待所有子任务进入终端状态，最后再安全收集已完成的结果。这样既符合结构化并发的设计要求，又能拿到你想要的部分结果。

修改后的代码如下：

import java.time.Instant;
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.TimeoutException;

public class Main {
    public static void main(String[] myData) {
        try (var scope = new StructuredTaskScope<String>()) {
            // 启动两个并行子任务
            var slowTask = scope.fork(() -> {
                Thread.sleep(3000);
                return "slow result";
            });
            var fastTask = scope.fork(() -> {
                Thread.sleep(1000);
                return "fast result";
            });

            boolean isTimedOut = false;
            try {
                // 等待2秒超时
                scope.joinUntil(Instant.now().plusMillis(2000));
            } catch (TimeoutException te) {
                System.out.println("整体任务超时，开始收尾未完成的子任务");
                isTimedOut = true;
                // 关键：主动取消所有未完成的子任务，让它们进入终端状态
                scope.shutdown();
            }

            // 如果超时了，等待所有子任务处理完取消操作（确保状态稳定）
            if (isTimedOut) {
                try {
                    scope.join();
                } catch (InterruptedException e) {
                    // 恢复中断状态，这是并发编程的良好习惯
                    Thread.currentThread().interrupt();
                    throw new RuntimeException("等待子任务取消时被中断", e);
                }
            }

            // 现在可以安全地处理每个子任务的结果了
            processTaskResult("1", slowTask);
            processTaskResult("2", fastTask);

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("主线程被中断", e);
        }
    }

    // 抽离结果处理逻辑，让代码更清晰
    private static void processTaskResult(String taskId, StructuredTaskScope.Subtask<String> task) {
        switch (task.state()) {
            case SUCCESS -> System.out.printf("任务%s 成功：%s%n", taskId, task.get());
            case FAILED -> System.out.printf("任务%s 失败：%s%n", taskId, task.exception().getMessage());
            case UNAVAILABLE -> System.out.printf("任务%s 未完成（已取消或超时）%n", taskId);
            default -> System.out.printf("任务%s 状态异常：%s%n", taskId, task.state());
        }
    }
}

代码里的关键细节 #

1. scope.shutdown()：向所有未完成的子任务发送中断信号，强制它们进入UNAVAILABLE状态，这样框架就不会认为你遗漏了子任务。
2. 超时后再调用scope.join()：等待所有子任务处理完取消逻辑，确保所有子任务的状态都稳定下来，此时调用task.get()就不会再触发异常。
3. 恢复中断状态：在捕获InterruptedException后，调用Thread.currentThread().interrupt()，让上层代码能感知到中断事件，这是并发编程的标准做法。

额外说明 #

如果你有特殊需求（比如超时后不想取消未完成的子任务），那其实已经违背了结构化并发的生命周期绑定设计，此时不如直接用CompletableFuture来实现，但这样会失去结构化并发带来的资源安全和可读性优势，不推荐。

内容来源于stack exchange