Skip to main content

Jakarta Concurrency

Jakarta Concurrency is a Jakarta EE specification that defines a standardized concurrency and threading model for Java application servers and managed environments.

  • Standardized concurrency APIs for Jakarta EE containers (application infrastructure)
  • Managed executor, scheduled, and context services for background tasks (application runtime)
  • Propagation and management of application context into concurrent tasks (application context management)
  • Container-managed thread lifecycle and resource control (resource management)
  • Integration of asynchronous task execution with Jakarta EE components and services (enterprise application integration)

More About Jakarta Concurrency

Jakarta Concurrency is a specification under the Jakarta EE umbrella that defines how concurrent tasks and threading are handled in managed Java application environments. It addresses how enterprise applications can use concurrency while remaining compatible with container-managed services such as transactions, security, naming, and resource management. The specification focuses on providing a standard set of managed concurrency services instead of relying on unmanaged Java Secure Element (SE) threads, which can conflict with container control.

The specification introduces container-managed services such as the managed executor service (application runtime), managed scheduled executor service (application runtime), context service (application context management), and managed thread factory (resource management). These services provide a consistent way to submit, schedule, and execute tasks while allowing the Jakarta EE container to control thread creation, pooling, and teardown. By using these services, applications can schedule work, run background tasks, and execute asynchronous processes within rules defined by the container.

Jakarta Concurrency defines how application context, such as security identities, classloader information, and naming contexts, is propagated from the calling component into tasks that execute asynchronously. The context service (application context management) allows applications to capture and apply specific context types when a task runs on a different thread. This enables use cases such as running background jobs that still operate under the correct security or transaction context defined by Jakarta EE services.

In enterprise environments, Jakarta Concurrency is used together with other Jakarta EE specifications (enterprise application platform) to implement non-blocking operations, task offloading, and scheduled jobs without bypassing the container. It is applicable in scenarios such as processing work queues, scheduling periodic maintenance tasks, and integrating with external systems using asynchronous patterns. Because these capabilities are standardized, application code using Jakarta Concurrency can run on any compliant Jakarta EE runtime that implements the specification.

The specification is developed and maintained under the Eclipse Foundation governance model (open standards), and its official materials describe the APIs, behavior, and requirements for compatible implementations. Jakarta Concurrency fits into directories and taxonomies in categories such as enterprise Java middleware, application server concurrency management, and asynchronous execution frameworks. For architects and platform engineers, it provides a defined contract for how concurrency is configured, monitored, and constrained in Jakarta EE environments, aligning background processing with operational policies around resource usage, security, and reliability.