{"id":664,"date":"2026-05-16T22:54:03","date_gmt":"2026-05-16T21:54:03","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=664"},"modified":"2026-06-16T22:58:39","modified_gmt":"2026-06-16T21:58:39","slug":"structured-concurrency-in-java-21-strukturierte-nebenlaeufigkeit-mit-structuredtaskscope","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=664","title":{"rendered":"Structured Concurrency in Java 21 \u2013 Strukturierte Nebenl\u00e4ufigkeit mit StructuredTaskScope"},"content":{"rendered":"\n

Nebenl\u00e4ufigkeit in Java war lange von zwei Mustern gepr\u00e4gt: ExecutorService<\/code> mit Future<\/code> und CompletableFuture<\/code> mit asynchronen Callbacks. Beide haben ihre Nachteile: Futures erfordern manuelle Synchronisation, und asynchrone Pipelines werden schnell un\u00fcbersichtlich. Mit Java 21 (JEP 453) wurde Structured Concurrency<\/strong> als Preview-Feature eingef\u00fchrt \u2013 ein Paradigma, das die Lebenszyklen nebenl\u00e4ufiger Tasks an den umgebenden Code kn\u00fcpft und Task-Abbruch sowie Fehlerbehandlung fundamental vereinfacht.<\/p>\n\n\n\n

Hinweis:<\/strong> Structured Concurrency ist zum Zeitpunkt der Artikelerstellung noch ein Preview-Feature und wurde in Java 22 (JEP 462), Java 23 (JEP 480) und Java 24 (JEP 499) weiter als Preview gef\u00fchrt. Die API kann sich bis zur Finalisierung noch \u00e4ndern. Um die Beispiele auszuf\u00fchren, muss mit --enable-preview<\/code> kompiliert und gestartet werden.<\/p>\n\n\n\n

Das Problem klassischer Nebenl\u00e4ufigkeit<\/h2>\n\n\n\n

Betrachten wir einen Service, der parallel drei externe APIs abfragt:<\/p>\n\n\n

ExecutorService executor = Executors.newFixedThreadPool(3<\/span>);\ntry<\/span> {\n    Future<String<\/span>> apiA = executor.submit(() -> rufeApiA());\n    Future<String<\/span>> apiB = executor.submit(() -> rufeApiB());\n    Future<String<\/span>> apiC = executor.submit(() -> rufeApiC());\n\n    String<\/span> ergebnisA = apiA.get();\n    String<\/span> ergebnisB = apiB.get();\n    String<\/span> ergebnisC = apiC.get();\n} finally<\/span> {\n    executor.shutdown();\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Mehrere Probleme fallen auf:<\/p>\n\n\n\n
    \n
  • Wenn\u00a0apiA.get()<\/code>\u00a0eine Exception wirft, laufen die anderen Tasks weiter, ohne abgebrochen zu werden \u2013 Ressourcenverschwendung<\/li>\n\n\n\n
  • Der\u00a0ExecutorService<\/code>\u00a0muss manuell heruntergefahren werden (sonst l\u00e4uft er ewig)<\/li>\n\n\n\n
  • Stacktraces sind schwer nachvollziehbar, weil Threads entkoppelt sind<\/li>\n<\/ul>\n\n\n\n
    StructuredTaskScope<\/h2>\n\n\n\n
    StructuredTaskScope<\/code> l\u00f6st diese Probleme, indem es Tasks an einen definierten Scope bindet. Der Scope ist AutoCloseable<\/code> \u2013 mit try-with-resources wird er automatisch geschlossen. Alle Tasks werden beim Verlassen des Scopes garantiert beendet.<\/p>\n\n\n
    try<\/span> (var<\/span> scope = new<\/span> StructuredTaskScope.ShutdownOnFailure()) {\n    Supplier<String<\/span>> apiA = scope.fork(() -> rufeApiA());\n    Supplier<String<\/span>> apiB = scope.fork(() -> rufeApiB());\n    Supplier<String<\/span>> apiC = scope.fork(() -> rufeApiC());\n\n    scope.join();           <em<\/span>><\/span>\/\/ Wartet auf alle Tasks und wirft bei Fehlern<\/em<\/span>><\/span><\/span>\n    scope.throwIfFailed();  <em<\/span>><\/span>\/\/ Propagiert Exceptions<\/em<\/span>><\/span><\/span>\n\n    String<\/span> ergebnis = apiA.get() + apiB.get() + apiC.get();\n    System.out.println(ergebnis);\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    Das Verhalten ist radikal anders als bei ExecutorService<\/code>:<\/p>\n\n\n\n
      \n
    • Schl\u00e4gt ein einzelner Task fehl, werden\u00a0alle anderen automatisch abgebrochen<\/strong><\/li>\n\n\n\n
    • Der Scope wird durch try-with-resources automatisch geschlossen<\/li>\n\n\n\n
    • Der aufrufende Thread wird von\u00a0join()<\/code>\u00a0blockiert \u2013 keine versteckten Thread-Leaks mehr<\/li>\n\n\n\n
    • Die Eltern-Kind-Beziehung der Threads bleibt erhalten \u2013 Stacktraces zeigen den vollst\u00e4ndigen Aufrufbaum<\/li>\n<\/ul>\n\n\n\n
      ShutdownOnSuccess \u2013 Der schnellste gewinnt<\/h2>\n\n\n\n
      Neben ShutdownOnFailure<\/code> gibt es ShutdownOnSuccess<\/code>, das sofort alle anderen Tasks abbricht, sobald ein Task erfolgreich war \u2013 ideal f\u00fcr redundante API-Abfragen:<\/p>\n\n\n
      try<\/span> (var<\/span> scope = new<\/span> StructuredTaskScope.ShutdownOnSuccess<String<\/span>>()) {\n    scope.fork(() -> rufeApiSpiegel1());\n    scope.fork(() -> rufeApiSpiegel2());\n    scope.fork(() -> rufeApiSpiegel3());\n\n    scope.join();\n    String<\/span> ergebnis = scope.result();\n    System.out.println(\"Schnellste Antwort: \"<\/span> + ergebnis);\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Sobald die erste API antwortet, werden die beiden anderen Tasks abgebrochen \u2013 ohne manuelles cancel()<\/code> oder Timeout-Logik.<\/p>\n\n\n\n
      Scoped Values als Erg\u00e4nzung<\/h2>\n\n\n\n
      Structured Concurrency wird oft mit Scoped Values<\/strong> kombiniert, um Kontext wie Request-IDs oder Benutzerinformationen ohne ThreadLocal<\/code> weiterzureichen. Scoped Values wurden ebenfalls in Java 21 als Preview eingef\u00fchrt (JEP 446) und sind bis einschlie\u00dflich Java 24 weiterhin im Preview-Status:<\/p>\n\n\n
      private<\/span> static<\/span> final<\/span> ScopedValue<String> REQUEST_ID = ScopedValue.newInstance();\n\nScopedValue.where(REQUEST_ID, \"abc-123\"<\/span>)\n    .run(() -> {\n        try<\/span> (var<\/span> scope = new<\/span> StructuredTaskScope.ShutdownOnFailure()) {\n            scope.fork(() -> verarbeiteMitRequestId(REQUEST_ID.get()));\n            scope.join();\n        }\n    });\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
      Jeder geforkte Task erbt den Scoped Value des Eltern-Threads automatisch \u2013 ohne explizites Kopieren.<\/p>\n\n\n\n
      Virtual Threads als Unterbau<\/h2>\n\n\n\n
      Structured Concurrency entfaltet seine volle Kraft mit Virtual Threads \u2013 den leichtgewichtigen Threads, die Java 21 ebenfalls mitbrachte:<\/p>\n\n\n
      try<\/span> (var<\/span> executor = Executors.newVirtualThreadPerTaskExecutor()) {\n    try<\/span> (var<\/span> scope = new<\/span> StructuredTaskScope.ShutdownOnFailure()) {\n        scope.fork(() -> rufeApiA());\n        scope.fork(() -> rufeApiB());\n        scope.fork(() -> rufeApiC());\n        scope.join();\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Der ExecutorService<\/code>-Ersatz hier nutzt Virtual Threads: jeder scope.fork()<\/code> erzeugt einen neuen Virtual Thread, der nur minimale Ressourcen verbraucht. Zehntausende parallele Aufgaben sind damit m\u00f6glich \u2013 mit Platform Threads undenkbar.<\/p>\n\n\n\n
      Benutzerdefinierte Error-Handler<\/h2>\n\n\n\n
      ShutdownOnFailure<\/code> behandelt Fehler automatisch, aber f\u00fcr granulare Kontrolle l\u00e4sst sich ein eigener StructuredTaskScope<\/code>-Subtyp schreiben:<\/p>\n\n\n
      class<\/span> BestEffortScope<\/span><T<\/span>> extends<\/span> StructuredTaskScope<\/span><T<\/span>> <\/span>{\n    private<\/span> final<\/span> List<\/span><T> results = new<\/span> ArrayList<>();\n\n    @Override\n    protected<\/span> void handleComplete(Subtask<?<\/span> extends T> subtask) {\n        if<\/span> (subtask.state() == Subtask.State.SUCCESS) {\n            results.add(subtask.get());\n        } else<\/span> {\n            <em>\/\/ Fehler ignorieren, mit erfolgreichen Ergebnissen weitermachen<\/em><\/span>\n            log.warn(\"Task fehlgeschlagen: {}\"<\/span>,\n                subtask.exception<\/span>().getMessage());\n        }\n    }\n\n    @Override\n    public<\/span> BestEffortScope<T> join() throws InterruptedException {\n        super.join();\n        return<\/span> this;\n    }\n\n    public<\/span> List<\/span><T> results() { return<\/span> results; }\n}\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
      Dieser \u201eBest Effort“-Scope sammelt erfolgreiche Ergebnisse und ignoriert Fehler \u2013 n\u00fctzlich, wenn mehrere optionale Datenquellen abgefragt werden.<\/p>\n\n\n\n
      Vergleich der Ans\u00e4tze<\/h2>\n\n\n\n
      Kriterium<\/th>ExecutorService<\/th>StructuredTaskScope<\/th><\/tr><\/thead>
      Task-Abbruch bei Fehler<\/td>nein (manuell)<\/td>automatisch<\/td><\/tr>
      Lebenszyklus<\/td>endlos (manuelles shutdown)<\/td>try-with-resources<\/td><\/tr>
      Thread-Eltern-Beziehung<\/td>entkoppelt<\/td>erhalten<\/td><\/tr>
      Stacktraces<\/td>fragmentiert<\/td>zusammenh\u00e4ngend<\/td><\/tr>
      Virtual-Thread-kompatibel<\/td>ja<\/td>optimiert<\/td><\/tr>
      Fehlerbehandlung<\/td>manuell per Future.get()<\/td>deklarativ per ShutdownOnFailure<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
      Fazit<\/h2>\n\n\n\n
      Structured Concurrency bringt eine l\u00e4ngst \u00fcberf\u00e4llige Ordnung in die nebenl\u00e4ufige Java-Programmierung. Tasks werden an definierte Scopes gebunden, automatisch beendet und Fehler werden konsistent propagiert. Mit Virtual Threads im R\u00fccken und Scoped Values f\u00fcr die Kontext-Propagation entsteht ein Programmiermodell, das die Komplexit\u00e4t klassischer Threads und Futures radikal reduziert. Wer heute neue Microservices in Java 21+ schreibt, sollte StructuredTaskScope<\/code> dem ExecutorService<\/code> vorziehen \u2013 der Code wird k\u00fcrzer, lesbarer und korrekter. Allerdings sollte beachtet werden, dass die API noch im Preview-Status ist und sich bis zur Finalisierung noch \u00e4ndern kann.<\/p>\n","protected":false},"excerpt":{"rendered":"
      Nebenl\u00e4ufigkeit in Java war lange von zwei Mustern gepr\u00e4gt: ExecutorService mit Future und CompletableFuture mit asynchronen Callbacks. Beide haben ihre Nachteile: Futures erfordern manuelle Synchronisation, und asynchrone Pipelines werden schnell un\u00fcbersichtlich. Mit Java 21 (JEP 453) wurde Structured Concurrency als Preview-Feature eingef\u00fchrt \u2013 ein Paradigma, das die Lebenszyklen nebenl\u00e4ufiger Tasks an den umgebenden Code kn\u00fcpft und Task-Abbruch sowie Fehlerbehandlung fundamental vereinfacht. Hinweis: Structured Concurrency […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-664","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/664","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=664"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/664\/revisions"}],"predecessor-version":[{"id":665,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/664\/revisions\/665"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=664"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=664"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=664"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}