[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"question-mnogopotochnost-chto-takoe-structured-concurrency-structuredtaskscope-i-zachem-eto-nuzhno":3},{"id":4,"slug":5,"topicId":6,"topicSlug":7,"topicName":8,"topicEmoji":9,"question":10,"answer":11,"codeLang":12,"codeSrc":12,"important":12,"commonMistakes":12,"modernUsage":12,"difficulty":13,"tags":14,"related":20,"progress":21,"seo":22},297,"chto-takoe-structured-concurrency-structuredtaskscope-i-zachem-eto-nuzhno",8,"mnogopotochnost","Многопоточность","🔀","Что такое Structured Concurrency (StructuredTaskScope) и зачем это нужно?","\u003C!-- grade: 5\u002F5 — отличное объяснение с мотивацией и примерами -->\n\n**Structured Concurrency** (структурированная конкуренция) — это подход к многопоточному программированию, в котором жизненный цикл параллельных задач привязан к области видимости кода, их породившего (JEP 462, preview в Java 21-23). Основная идея: если задача порождает подзадачи, **все они должны завершиться до завершения родительской задачи**.\n\n**Проблема неструктурированной конкуренции:**\n\n```java\n\u002F\u002F Unstructured concurrency — поток может «убежать»\nExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();\nFuture\u003CString> user = executor.submit(() -> fetchUser(id));\nFuture\u003CString> orders = executor.submit(() -> fetchOrders(id));\n\u002F\u002F Что если fetchUser() упал? fetchOrders() продолжает работать зря!\n\u002F\u002F Что если текущий поток был прерван? Подзадачи продолжают работать!\n```\n\nЭто приводит к: утечкам потоков, сложности отладки, неполной обработке ошибок.\n\n**Решение через StructuredTaskScope:**\n\n```java\nString handle(String userId) throws ExecutionException, InterruptedException {\n    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {\n        Subtask\u003CString> user = scope.fork(() -> fetchUser(userId));\n        Subtask\u003CString> orders = scope.fork(() -> fetchOrders(userId));\n\n        scope.join();            \u002F\u002F Ожидание завершения всех подзадач\n        scope.throwIfFailed();   \u002F\u002F Если любая подзадача упала — бросаем исключение\n\n        return user.get() + \" : \" + orders.get();\n    }\n    \u002F\u002F При выходе из try-with-resources все незавершённые подзадачи отменяются\n}\n```\n\n**Стратегии завершения:**\n\n| Стратегия | Поведение | Паттерн |\n|---|---|---|\n| `ShutdownOnFailure` | При ошибке в любой подзадаче — все остальные отменяются | «Всё или ничего» |\n| `ShutdownOnSuccess` | При успехе любой подзадачи — все остальные отменяются | «Первый успешный» |\n\n\u003Cdetails>\n\u003Csummary>Код: получение первого успешного результата\u003C\u002Fsummary>\n\n```java\ntry (var scope = new StructuredTaskScope.ShutdownOnSuccess\u003CString>()) {\n    scope.fork(() -> fetchFromServer1());\n    scope.fork(() -> fetchFromServer2());\n    scope.fork(() -> fetchFromServer3());\n\n    scope.join();\n    String fastest = scope.result(); \u002F\u002F результат первого завершившегося\n}\n```\n\n\u003C\u002Fdetails>\n\n**Гарантии Structured Concurrency:**\n- Все дочерние потоки завершатся до выхода из `try-with-resources`.\n- Стек вызовов дочерних потоков содержит информацию о родительском scope — упрощает отладку.\n- `StructuredTaskScope` предназначен для использования с Virtual Threads — каждая `fork()` создаёт виртуальный поток.\n\n**Частые ошибки:**\n- `fork()` после `join()` — приведёт к исключению.\n- Забытый `join()` — задачи могут не завершиться.\n- Использование для длительных фоновых задач — это инструмент для короткоживущих параллельных подзадач.\n\n> **Аналогия:** Structured Concurrency — это правила воспитания. Родитель (scope) отправляет детей (подзадачи) гулять, но обязан дождаться, пока все вернутся, прежде чем закрыть дверь (выйти из блока). Если один ребёнок попал в беду (ошибка) — родитель зовёт всех обратно (shutdown).\n\n> **На собеседовании** хороший ответ включает мотивацию: «Structured Concurrency делает для потоков то, что структурное программирование сделало для goto — превращает хаос в предсказуемую структуру». Также упомяните, что это preview feature, ожидается стабилизация.","","senior",[15,16,17,18,19],"Java-21","Structured-Concurrency","Virtual-Threads","StructuredTaskScope","concurrency",[],null,{"title":23,"description":24,"ogTitle":25,"ogDescription":26,"keywords":27,"schemaAnswer":32,"featuredSnippetReady":33},"Structured Concurrency и StructuredTaskScope в Java 21 — Gymterview","Structured Concurrency привязывает жизненный цикл подзадач к родительской области видимости. ShutdownOnFailure и ShutdownOnSuccess стратегии.","StructuredTaskScope — структурированная конкуренция в Java","StructuredTaskScope гарантирует, что все дочерние потоки завершатся до выхода из блока. ShutdownOnFailure — все или ничего, ShutdownOnSuccess — первый успешный.",[28,18,29,30,31],"Structured Concurrency Java","ShutdownOnFailure","ShutdownOnSuccess","структурированная конкуренция","Structured Concurrency (JEP 462) — подход, при котором жизненный цикл параллельных подзадач привязан к области видимости кода. StructuredTaskScope гарантирует, что все fork-подзадачи завершатся до выхода из try-with-resources. Стратегии: ShutdownOnFailure (отмена всех при ошибке любой), ShutdownOnSuccess (отмена при первом успехе). Решает проблемы утечек потоков и неполной обработки ошибок.",true]