Jakarta Concurrency

using CDI beans as tasks.

Specification: Jakarta Concurrency

Version: 3.1

Status: FINAL

Release: June 21, 2024
<resource-env-ref>
  <description>
    This executor is used for the application’s reporter task.
    This executor has the following requirements:
    Context Info: Local Namespace
  </description>
  <resource-env-ref-name>
    concurrent/LongRunningTasksExecutor
  </resource-env-ref-name>
  <resource-env-ref-type>
    jakarta.enterprise.concurrent.ManagedExecutorService
  </resource-env-ref-type>
</resource-env-ref>
public class ReporterTask implements Runnable {
  String reportName;

  public ReporterTask(String reportName) {
    this.reportName = reportName;
  }

public void run() {
  // Run the named report
  if("TransactionReport".equals(reportName)) {
    runTransactionReport();
  }
  else if("SummaryReport".equals(reportName)) {
    runSummaryReport();
  }
}

DataSource ds = …;

void runTransactionReport() {
  try (Connection con = ds.getConnection(); ...) {

    // Read/Write the data using our connection.
    ...
    // Commit.
    con.commit();
  }
}
public class AppServlet extends HTTPServlet implements Servlet {

  // Cache our executor instance
  @Resource(name=”concurrent/LongRunningTasksExecutor”)
  ManagedExecutorService mes;

  protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

    // Get the name of the report to run from the input params...
    // Assemble the header for the response.
    // Create a task instance
    ReporterTask reporterTask = new ReporterTask(reportName);

    // Submit the task to the ManagedExecutorService
    Future reportFuture = mes.submit(reporterTask);

    // Cache the future somewhere (like the client's session)
    // The client can then poll the servlet to determine
    // the status of the report.
    ...

    // Tell the user that the report has been submitted.
    ...
  }
}
<resource-env-ref>
  <description>
    This executor is used for the application’s builder tasks.
    This executor has the following requirements:
    Context Info: Local Namespace, Security
  </description>
  <resource-env-ref-name>
    concurrent/BuilderExecutor
  </resource-env-ref-name>
  <resource-env-ref-type>
    jakarta.enterprise.concurrent.ManagedExecutorService
  </resource-env-ref-type>
</resource-env-ref>
public class AccountTask implements Callable<AccountInfo>, ManagedTask
{
  // The ID of the request to report on demand.
  String reqID;

  String accountID;
  Map<String, String> execProps;

  public AccountTask(String reqID, String accountID) {
    this.reqID=reqID;
    this.accountID=accountID;
    execProps = new HashMap<>();
    execProps.put(ManagedTask.IDENTITY_NAME, getIdentityName());
  }

  public AccountInfo call() {

    // Retrieve account info for the account from some persistent store
    AccountInfo info = ...;
    return info;
  }

  public String getIdentityName() {
    return "AccountTask: ReqID=" + reqID + ", Acct=" + accountID;
  }

  public Map<String, String> getExecutionProperties() {
    return execProps;
  }

  public ManagedTaskListener getManagedTaskListener() {
    return null;
  }
}

public class InsuranceTask implements Callable<InsuranceInfo>, ManagedTask {

  // The ID of the request to report on demand.
  String reqID

  String accountID;
  Map<String, String> execProps;

  public InsuranceTask (String reqID, String accountID) {
    this.reqID=reqID;
    this.accountID=accountID;
    execProps = new HashMap<>();

    execProps.put(ManagedTask.IDENTITY_NAME, getIdentityName());
  }

  public InsuranceInfo call() {
    // Retrieve the insurance info for the account from some persistent store
    InsuranceInfo info = ...;
    return info;
  }

  public String getIdentityName() {
    return "InsuranceTask: ReqID=" + reqID + ", Acct=" + accountID;
  }

  public Map<String, String> getExecutionProperties()
    return execProps;
  }

  public ManagedTaskListener getManagedTaskListener() {
    return null;
  }
}
public class AppServlet extends HttpServlet implements Servlet {

  // Retrieve our executor instance.
  @Resource(name=”concurrent/BuilderExecutor”)
  ManagedExecutorService mes;

  protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    // Get our arguments from the request (accountNumber and
    // requestID, in this case.
    // Assemble the header for the response.
    // Create and submit the task instances

    Future<AccountInfo> acctFuture = mes.submit(new AccountTask(reqID, accountID));

    Future<InsuranceInfo> insFuture = mes.submit (new InsuranceTask(reqID, accountID));

    // Wait for the results.
    AccountInfo accountInfo = acctFuture.get();
    InsuranceInfo insInfo = insFuture.get();

    // Process the results
  }
}

Jakarta Concurrency

Eclipse Foundation Specification License - v1.1

Disclaimers

Jakarta Concurrency Specification, Version 3.1

1. Introduction

1.1. Overview

1.2. Goals of this specification

1.3. Other Java Platform and Jakarta Specifications

1.4. Concurrency Utilities for Java EE Expert Group at the JCP

1.5. Document Conventions

2. Overview

2.1. Container-Managed vs. Unmanaged Threads

2.2. Application Integrity

2.3. Container Thread Context

2.3.1. Contextual Invocation Points

2.3.1.1. Flow Contextual Invocation Points

2.3.1.2. Optional Contextual Invocation Points

2.3.2. Contextual Objects and Tasks

2.3.2.1. Tasks and Jakarta Contexts and Dependency Injection (CDI)

2.4. Usage with Jakarta Connectors

2.5. Security

3. Managed Objects

3.1. ManagedExecutorService

3.1.1. Application Component Provider’s Responsibilities

3.1.1.1. Usage Example

Reporter Task

Resource Environment Reference - Reporter Task

Task Definition – Reporter Task

Task Submission – Reporter Task

Builder Tasks

Resource Environment Reference – Builder Tasks

Task Definition – Builder Tasks

Task Invocation – Builder Tasks

3.1.2. Application Assembler’s Responsibilities

3.1.3. Deployer’s Responsibilities

3.1.4. Jakarta EE Product Provider’s Responsibilities

3.1.4.1. ManagedExecutorService Configuration Attributes

3.1.4.2. Configuration Examples

Typical Thread Pool

Thread Pool for Long-Running Tasks

OLTP Thread Pool

3.1.4.3. Default ManagedExecutorService

3.1.5. System Administrator’s Responsibilities

3.1.6. Lifecycle