<!-- mobian-agent-page publisher="dailydev" canonical="https://daily.dev/posts/virtual-threads-aren-t-enough-structured-concurrency-in-java-27-bos2c4l6z" -->

---
title: Virtual Threads Aren't Enough: Structured Concurrency in...
description: A walkthrough of structured concurrency, now in its seventh preview in JDK 27, as part of Project Loom alongside virtual threads (final since JDK 21) and...
canonical: https://daily.dev/posts/virtual-threads-aren-t-enough-structured-concurrency-in-java-27-bos2c4l6z
twitter:card: summary_large_image
twitter:site: @dailydotdev
og:type: website
og:site_name: daily.dev
og:title: Virtual Threads Aren't Enough: Structured Concurrency in Java 27 | daily.dev
og:description: A walkthrough of structured concurrency, now in its seventh preview in JDK 27, as part of Project Loom alongside virtual threads (final since JDK 21) and...
og:url: https://daily.dev/posts/virtual-threads-aren-t-enough-structured-concurrency-in-java-27-bos2c4l6z
og:image: https://api.daily.dev/og/posts/boS2c4l6Z.png
og:image:alt: Virtual Threads Aren't Enough: Structured Concurrency in Java 27
og:image:width: 1200
og:image:height: 630
og:locale: en
---

> ## Documentation Index
> Fetch the complete documentation index at: https://daily.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Virtual Threads Aren't Enough: Structured Concurrency in Java 27

**[Dan Vega](https://daily.dev/sources/dan-vega)** · 24 min read · 0 upvotes · 0 comments

## Summary

A walkthrough of structured concurrency, now in its seventh preview in JDK 27, as part of Project Loom alongside virtual threads (final since JDK 21) and scoped values (final since JDK 25). The video contrasts sequential code, virtual-thread-based parallel calls using ExecutorService and Future (which don't cancel or coordinate related tasks), and the structured concurrency approach using StructuredTaskScope and subtasks, which ties related tasks to a single scope that succeeds or fails together via scope.join(). Code examples build a mock dashboard that fetches user and order data, showing that failures are detected immediately (in ~200ms) instead of waiting for the slower call to finish. Structured concurrency is expected to go final in JDK 28, since the ramp-down phase for that release doesn't start until around December.

## Full article

daily.dev links to this article rather than hosting it. Read it at the original source: <https://www.youtube.com/watch?v=Nl-a4ukWodk>

## Questions this post answers

### What is structured concurrency in JDK 27 and how does it differ from using virtual threads with Future?

Structured concurrency, in its seventh preview in JDK 27, groups related subtasks into a single StructuredTaskScope with one lifetime so they succeed or fail together. Unlike ExecutorService with Future, where a failing task doesn't cancel its sibling and get() calls block independently, StructuredTaskScope automatically interrupts the other subtask on failure and reports errors via scope.join() before any blocking get is needed.

_Developers wiring up concurrent service calls can track how structured concurrency matures toward JDK 28 on daily.dev._

### When will structured concurrency become a final feature in the JDK?

Structured concurrency is expected to become final in JDK 28, since it reached its seventh preview in JDK 27 and the JDK 28 ramp-down phase does not start until around December, leaving time for the API to settle. It is not guaranteed, but that is the current plan following changes made to the API in JDK 27.

_Java developers planning concurrency upgrades can follow JDK 28 finalization progress via daily.dev._

### What are the three main JEPs that make up Project Loom in the JDK?

Project Loom consists of three main JEPs: virtual threads, which made threads cheap and went final in JDK 21 with fixes in JDK 24; scoped values, a safer alternative to thread-local variables that went final in JDK 25; and structured concurrency, which groups related tasks into one scope and is currently in its seventh preview in JDK 27.

_Teams adopting lightweight JVM concurrency can track each Project Loom component's status on daily.dev._

## Similar posts on daily.dev

- [Project Loom in IntelliJ IDEA: Virtual Threads, Scoped Values, and Structured Concurrency](https://daily.dev/posts/project-loom-in-intellij-idea-virtual-threads-scoped-values-and-structured-concurrency-553sohxk8) · JetBrains · 4 upvotes · 0 comments
- [JEP 525: Structured Concurrency \(Sixth Preview\)](https://daily.dev/posts/jep-525-structured-concurrency-sixth-preview--0p1e9yjdb) · Inside Java · 0 upvotes · 0 comments
- [JEP draft: Structured Concurrency](https://daily.dev/posts/jep-draft-structured-concurrency-xkio5cvnc) · Awesome Java Newsletter · 1 upvotes · 0 comments

---

Tags: [#java](https://daily.dev/tags/java), [#jdk](https://daily.dev/tags/jdk)

[View this post on daily.dev](https://daily.dev/posts/virtual-threads-aren-t-enough-structured-concurrency-in-java-27-bos2c4l6z)

```json
{"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]}
{"@context":"https://schema.org","@type":"TechArticle","headline":"Virtual Threads Aren't Enough: Structured Concurrency in Java 27","url":"https://daily.dev/posts/virtual-threads-aren-t-enough-structured-concurrency-in-java-27-bos2c4l6z","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/virtual-threads-aren-t-enough-structured-concurrency-in-java-27-bos2c4l6z"},"datePublished":"2026-09-18T12:29:43.593Z","dateModified":"2026-09-18T12:30:08.271Z","description":"A walkthrough of structured concurrency, now in its seventh preview in JDK 27, as part of Project Loom alongside virtual threads (final since JDK 21) and...","image":"https://i.ytimg.com/vi/Nl-a4ukWodk/sddefault.jpg","thumbnailUrl":"https://i.ytimg.com/vi/Nl-a4ukWodk/sddefault.jpg","isAccessibleForFree":true,"articleSection":"Dan Vega","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"Dan Vega","logo":"https://media.daily.dev/image/upload/s--qCQZxa91--/f_auto,q_auto/v1773648785/logos/dan-vega?_a=BAMAMiiu0","url":"https://daily.dev/sources/dan-vega"},"commentCount":0,"discussionUrl":"https://daily.dev/posts/virtual-threads-aren-t-enough-structured-concurrency-in-java-27-bos2c4l6z","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":0},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":0}],"keywords":"java,jdk","timeRequired":"PT24M","video":{"@type":"VideoObject","name":"Virtual Threads Aren't Enough: Structured Concurrency in Java 27","description":"A walkthrough of structured concurrency, now in its seventh preview in JDK 27, as part of Project Loom alongside virtual threads (final since JDK 21) and...","thumbnailUrl":"https://i.ytimg.com/vi/Nl-a4ukWodk/sddefault.jpg","uploadDate":"2026-09-18T12:29:43.593Z","duration":"PT24M","url":"https://api.daily.dev/r/boS2c4l6Z","embedUrl":"https://www.youtube.com/embed/Nl-a4ukWodk"}}
{"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"Dan Vega","item":"https://daily.dev/sources/dan-vega"},{"@type":"ListItem","position":3,"name":"Virtual Threads Aren't Enough: Structured Concurrency in Java 27"}]}
{"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/virtual-threads-aren-t-enough-structured-concurrency-in-java-27-bos2c4l6z#faq","mainEntity":[{"@type":"Question","name":"What is structured concurrency in JDK 27 and how does it differ from using virtual threads with Future?","acceptedAnswer":{"@type":"Answer","text":"Structured concurrency, in its seventh preview in JDK 27, groups related subtasks into a single StructuredTaskScope with one lifetime so they succeed or fail together. Unlike ExecutorService with Future, where a failing task doesn't cancel its sibling and get() calls block independently, StructuredTaskScope automatically interrupts the other subtask on failure and reports errors via scope.join() before any blocking get is needed. Developers wiring up concurrent service calls can track how structured concurrency matures toward JDK 28 on daily.dev."}},{"@type":"Question","name":"When will structured concurrency become a final feature in the JDK?","acceptedAnswer":{"@type":"Answer","text":"Structured concurrency is expected to become final in JDK 28, since it reached its seventh preview in JDK 27 and the JDK 28 ramp-down phase does not start until around December, leaving time for the API to settle. It is not guaranteed, but that is the current plan following changes made to the API in JDK 27. Java developers planning concurrency upgrades can follow JDK 28 finalization progress via daily.dev."}},{"@type":"Question","name":"What are the three main JEPs that make up Project Loom in the JDK?","acceptedAnswer":{"@type":"Answer","text":"Project Loom consists of three main JEPs: virtual threads, which made threads cheap and went final in JDK 21 with fixes in JDK 24; scoped values, a safer alternative to thread-local variables that went final in JDK 25; and structured concurrency, which groups related tasks into one scope and is currently in its seventh preview in JDK 27. Teams adopting lightweight JVM concurrency can track each Project Loom component's status on daily.dev."}}]}
```

