Lernen Principles of Structured Concurrency | Structured Concurrency with Virtual Threads

Swipe um das Menü anzuzeigen

Structured concurrency is a design principle that helps you manage the lifecycle of concurrent tasks in a clear, predictable way. When using virtual threads in Java Project Loom, structured concurrency ensures that tasks are started, monitored, and completed within well-defined scopes. This approach prevents resource leaks, makes error handling more reliable, and simplifies reasoning about concurrent code. By following structured concurrency, you gain better control over how virtual threads interact and finish, making your backend applications safer, more robust, and easier to maintain.

What Is Structured Concurrency?

Structured concurrency is a programming approach that organizes concurrent tasks into well-defined, hierarchical scopes. Each scope controls the lifetime of its concurrent tasks, ensuring that tasks start and finish together as a group. This structure makes it easier to reason about concurrent code, especially when using virtual threads in Java.

Benefits for Managing Virtual Threads

When you use virtual threads, structured concurrency provides several key advantages:

Improves code readability;
Simplifies error handling by grouping related tasks;
Ensures proper resource management and cleanup;
Prevents orphaned or "leaked" threads by enforcing clear boundaries;
Makes it easier to detect and handle failures within a group of tasks.

How Structured Concurrency Works

With structured concurrency, you launch multiple virtual threads within a defined scope, such as a method or a code block. The parent scope waits for all child tasks (virtual threads) to finish before it completes. If an error occurs in any child thread, the structure allows you to cancel or handle all related tasks together, reducing the risk of inconsistent state.

This approach contrasts with "unstructured concurrency," where threads may be launched and forgotten, making it hard to track their lifecycles, manage exceptions, or free resources properly.

Example Scenario

Suppose you need to fetch data from several external services at the same time. Using structured concurrency, you can start a virtual thread for each request within a single scope. When all threads finish, you safely process the results. If one request fails, you can immediately handle the error and stop the other threads, keeping your code clear and robust.

StructuredConcurrencyDemo.java


              1234567891011121314
            
package com.example;

import java.util.concurrent.*;

public class StructuredConcurrencyDemo {
    public static void main(String[] args) throws Exception {
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            Future<String> hello = scope.fork(() -> "Hello");
            Future<String> world = scope.fork(() -> "World");
            scope.join().throwIfFailed();
            System.out.println(hello.resultNow() + " " + world.resultNow());
        }
    }
}

The code example demonstrates how to use Java's virtual threads to manage multiple concurrent tasks within a structured block. By launching several virtual threads inside a try-with-resources block using StructuredTaskScope, all tasks are started together and their lifecycles are tied to the scope. This ensures that if one task fails or completes, the scope can handle cleanup and cancellation of the others, illustrating the core principles of structured concurrency: clear task boundaries, predictable resource management, and simplified error handling.

War alles klar?

Danke für Ihr Feedback!

Abschnitt 2. Kapitel 1

Fragen Sie AI

Fragen Sie alles oder probieren Sie eine der vorgeschlagenen Fragen, um unser Gespräch zu beginnen

Abschnitt 2. Kapitel 1