Structured concurrency: A new proposal from the OpenJDK community treats multiple tasks in different threads as a single unit of work
Multithreaded programming could be on the verge of becoming more accessible for Java developers thanks to a new plan currently being explored within the OpenJDK community. The proposal, known as structured concurrency, aims to introduce a library that treats multiple tasks running in separate threads as a single unit of work. This could greatly simplify error handling and cancellation processes, thus enhancing the reliability and observability of multithreaded applications. The structured concurrency initiative is designed to address common issues associated with concurrent programming, such as thread leaks and delays in task cancellation, though it is not yet slated for inclusion in any specific version of Java.
Structured concurrency seeks to bring the clarity and maintainability of single-threaded programming to multithreaded scenarios. The core idea is that if a task spawns multiple concurrent subtasks, they should all return to the same point of control—the task’s original code block. This principle ensures that the lifecycle of these subtasks is confined within a specific syntactic block, allowing them to be managed and reasoned about as a cohesive unit. This approach mirrors structured programming techniques in single-threaded contexts, where code execution is guided by well-defined entry and exit points.
In practical terms, structured concurrency organizes tasks into a tree-like hierarchy at runtime, with sibling subtasks grouped under a single parent task. This hierarchy is akin to the call stack in single-threaded programming, providing a clear and manageable structure for concurrent operations.
This proposal aligns well with the introduction of virtual threads, a new lightweight threading mechanism provided by the JDK. A preview of virtual threads is expected in Java 19 this September, and their ability to share OS threads makes them suitable for handling a high volume of concurrent tasks, such as processing numerous simultaneous requests in a server application. Structured concurrency will complement this by ensuring that the virtual threads are coordinated effectively, thus enhancing both maintainability and reliability.
The proposed library for structured concurrency does not intend to replace existing concurrency constructs in java.util.concurrent or offer a final API for structured concurrency at this stage. It also does not plan to introduce new mechanisms for sharing data streams among threads or replace the current thread interruption mechanisms. However, these aspects may be explored in future updates.
In summary, the structured concurrency proposal represents a significant step forward in making multithreaded programming more straightforward and reliable for Java developers. By integrating this approach with virtual threads, developers can benefit from an abundance of lightweight threads and a structured method for managing them, ultimately leading to more robust and maintainable concurrent applications