JSR 236 Concurrency Utils for EE presentation for JavaOne 2013 (CON7948)

JSR 236: Introduction to
Concurrency Utilities for
Java EE 1.0
Anthony Lai
Oracle
Fred Rowe
IBM

The following is intended to outline our general product direction. It is intended
for information purposes only, and may not be incorporated into any contract.
It is not a commitment to deliver any material, code, or functionality, and should
not be relied upon in making purchasing decisions. The
development, release, and timing of any features or functionality described for
Oracle’s products remains at the sole discretion of Oracle.

Program Agenda
 Overview
 Managed Objects
 Features
 Summary
 Resources

Overview
 Provide a simple and flexible standard API for application component
providers to design applications using concurrency design principles
 Provide a simple migration path from Java SE Concurrency Utilities
(JSR-166) to the Java EE platform by providing consistency between
the two platforms
 Allow application component providers to easily add concurrency to
existing Java EE applications
 Support simple and advanced concurrency patterns without sacrificing
usability
Goals

Overview
 2003 – JSR 236 and JSR237 filed. CommonJ API provides context
aware Work Managers and Timers to Java EE applications
 2006 – CommonJ API replaced by API that extends from Java SE
concurrency utilities
 2008 – Merged into JSR 236
 2008 – 2012 …
 2012 – JSR 236 restarted
 2013 – JSR 236 released and become part of Java EE 7
History

Overview
 Simple, standardized API for using concurrency from application
components
 Extension of Java SE Concurrency Utilities APIs (JSR-166)
 Provide low-level asynchronous processing capabilities to Java EE
application components in a safe, reliable, consistent manner
 Manage and monitor the lifecycle of asynchronous operations
Main Features

Overview
 Provides 4 types of managed objects that implement these interfaces
in javax.enterprise.concurrent package:
– ManagedExecutorService
– ManagedScheduledExecutorService
– ManagedThreadFactory
– ContextService
 Container context propagation
 Transaction management
 Task events notification
Main Features

Program Agenda
 Overview
 Managed Objects
 Features
 Summary
 Resources

Managed Objects
 Managed Objects are provided by the Java EE Product Provider
 Applications access managed objects by
– JNDI lookup
– resource injection using @Resource
 Configurable
 Pre-configured default managed objects are available
– e.g. java:comp/DefaultManagedThreadFactory
Overview

ManagedThreadFactory
 A standard way for applications to obtain a container-managed
threads from Java EE Containers
 Supports context propagation
 Can be used with asynchronous processing API in Servlets
 Can be used for creating custom executors in advanced use cases
Overview

 Interface extends from java.util.concurrent.ThreadFactory
– Same API: Thread.newThread(Runnable)
– Container context captured at ManagedThreadFactory creation
will be propagated to the thread returned
 Threads returned by newThread() method are required to implement
the ManagableThread interface
– boolean isShutdown()
 Can be used with Java SE concurrency utilities APIs where
ThreadFactory is needed. e.g. in
java.util.concurrent.Executors
API

 Thread interrupted when ManagedThreadFactory shuts down
 Runnable implementations should check
ManagableThread.isShutdown() when interrupted
– clean up if it returns true
Shutdown

// Create a ThreadPoolExecutor using a ManagedThreadFactory.
@Resource ManagedThreadFactory tf;
public ExecutorService getManagedThreadPool() {
// All threads will run as part of this application component.
return new ThreadPoolExecutor(5, 10, 5, TimeUnit.SECONDS,
new ArrayBlockingQueue<Runnable>(10), tf);
}
Example 1

@WebServlet(asyncSupported=true)
public class TestServlet extends HttpServlet {
@Resource private ManagedThreadFactory managedThreadFactory;
protected void doGet(HttpServletRequest
req, HttpServletResponse res {
final AsyncContext asyncContext = req.startAsync();
…
Runnable runnable = new Runnable() {
public void run() {
…
asyncContext.complete();
}
};
Thread thread = managedThreadFactory.newThread(runnable);
thread.start();
…
}
}
Example 2 – Use with Asynchronous Servlet

ManagedExecutorService
 For running tasks asynchronously on threads provided by Java EE
product provider
– Tasks must implement either java.util.concurrent.Callable or
java.lang.Runnable
 Allow application developers to use familiar Java SE APIs for
concurrent processing of tasks in Java EE
Overview

 Extends from java.util.concurrent.ExecutorService
– execute, submit, invokeAll, invokeAny
– No new APIs
 Future is returned upon task submission
– Checks for the task execution status
– Cancels the task
– Waits and retrieves result
 Lifecycle APIs disabled – throws IllegalStateException
– awaitTermination, isTerminated, isShutdown, shutdown, shutd
ownNow
API

Example 1
@Resource ManagedExecutorService mes;
void someMethod() {
Callable<Integer> c = new Callable<>() {
Integer call() {
// Interact with a database...return answer.
}
//Submit the task and do something else.
Future result = mes.submit(c);
...
//Get the result when ready...
int theValue = result.get();
...

Example 2 – Use with Asynchronous Servlet
@WebServlet(asyncSupported=true)
public class TestAsyncMESServlet extends HttpServlet {
@Resource private ManagedExecutorService
managedExecutorService;
protected void doGet(HttpServletRequest
req, HttpServletResponse res {
final AsyncContext asyncContext = req.startAsync();
…
Runnable runnable = new Runnable() {
public void run() {
…
asyncContext.complete();
}
};
managedExecutorService.submit(runnable);
…
}
}

Managed Thread Pool Executor Component Relationship

ManagedScheduledExecutorService
 For scheduling tasks to run
– after a given delay
– periodically
– at some custom schedule
 Tasks are run on threads that are provided by the Java EE container
 Allows application developers to use familiar Java SE APIs for
submitting scheduled tasks in Java EE
Overview

 Extends from ManagedExecutorService
 Extends from
java.util.concurrent.ScheduledExecutorService
– schedule, scheduleAtFixedRate, scheduleWithFixedDelay
 Lifecycle APIs disabled – throws IllegalStateException
– awaitTermination, isTerminated, isShutdown, shutdown, shutd
ownNow
 Extension API to support custom scheduling
– schedule with Trigger
API

API from ScheduledExecutorService
<V> ScheduledFuture<V> schedule(Callable<V> callable, long delay,
TimeUnit unit);
ScheduledFuture<?> schedule(Runnable command, long delay,
TimeUnit unit);
ScheduledFuture<?> scheduleAtFixedFate(Runnable command,
long initialDelay, long period, TimeUnit unit);
ScheduledFuture<?> scheduledWithFixedDelay(Runnable command,
long initialDelay, long delay, TimeUnit unit);

API for Custom Scheduling
<V> ScheduledFuture<V> schedule(Callable<V> callable, Trigger trigger);
ScheduledFuture<?> schedule(Runnable command, Trigger trigger);

Trigger
 For supporting custom scheduling rules
– Can be simple: single, absolute date/time
– Can be complex calendar logic
– Next trigger time can be calculated based on previous trigger execution
date/time and result
 Implemented by application developers
 Submitted along with a task using the schedule method in

Trigger API
boolean skipRun(LastExecution lastExecutionInfo,
Date scheduledRunTime)
Date getNextRunTime(LastExecution
lastExecutionInfo, Date taskScheduledTime)

Trigger Example
public class SimpleFixedDateTrigger implements Trigger {
private Date fireTime;
public SimpleFixedDateTrigger(Date triggerDate) {
fireTime = triggerDate;
}
public Date getNextRunTime(
LastExecution lastExecutionInfo, Date taskScheduledTime) {
if(taskScheduledTime.after(fireTime)) {
return null;
}
return fireTime;
}
public boolean skipRun(LastExecution lastExecutionInfo, Date
scheduledRunTime) {
return scheduledRunTime.after(fireTime);
}
}

ContextService
 For creating contextual proxy objects
– Application context is captured upon creation
– Proxy object methods will run within the captured context at a later time
 For use in advanced use cases
– E.g. to propagate user identity
– E.g. to request task listener notifications to be run under container context
 Uses dynamic proxy mechanism in java.lang.reflect package
Overview

ContextService
 Contextual proxy objects customizable through execution properties
– Transaction property
– Vendor specific properties, e.g. vendorA.security_token_expiration
 API for returning the execution properties on the given contextual
object proxy instance
– Map<String,String> getExecutionProperties(Object
contextualProxy)
Execution Properties

ContextService
 For creating contextual proxy objects:
– <T> T createContextualProxy(T instance, Class<T> intf)
– Object createContextualProxy(Object
instance, Class<?>... Interfaces)
– <T> T createContextualProxy(T
instance, Map<String,String>
executionProperties, Class<T> intf)
– Object createContextualProxy(Object
instance, Map<String,String>
executionProperties, Class<?>... Interfaces)
API

ContextService
Example 1
@Resource ContextService ctxSvc;
MyAppIntf proxy =
ctxSvc.createContextualProxy (myAppImpl, MyAppIntf.class);
// invoke at a later time, possibly in a different app
// component
proxy.doSomething();

ContextService
Example 2
// In application
public interface MessageProcessor {
public void processMessage(Message msg)
…
}
// Within servlet or EJB method…
@Resource ContextService ctxSvc;
void businessMethod() {
MessageProcessor msgProcessor = …
// Wrap with the current context
MessageProcessor proxy = ctxSvc.createContextualProxy
(msgProcessor, MessageProcessor.class);
// Store the contextual proxy object somewhere for running later.
store.putIt(proxy);
…

ContextService
Example 2 (cont’d)
// Elsewhere, in a different thread, retrieve the MessageProcessor contextual proxy
// object from the store
MessageProcessor proxy = store.getIt();
// The proxy method processMessage() is invoked on
// this thread, but with the context of the servlet or
// EJB that created it.
proxy.processMessage(msg);

Program Agenda
 Overview
 Managed Objects
 Features
 Summary
 Resources

Context Propagation
 Types of container context to be propagated
– Class loading, JNDI namespace, security identity
 Configurable
 Extensible
 Supported in all 4 types of managed objects
Overview

Context Propagation
 Application context captured at
– Task submission
– ManagedThreadFactory creation
– Contextual proxy object creation
 Application context propagated to thread
– Before task execution
– During invocation of contextual proxy object methods (with the
exception of hashCode, equals, toString and all other methods
declared in Object)
Overview (cont’d)

Transaction Management
 Transactions are not propagated to the threads where tasks are run
 UserTransaction from JTA is available
 Contextual proxy objects from ContextService can be run on the
same transaction context of the invoking thread
– Configurable via execution property ManagedTask.TRANSACTION
 ManagedTask.SUSPEND (default)
 ManagedTask.USE_TRANSACTION_OF_EXECUTION_THREAD
Overview

Task Events Notifications
 Task lifecycle events notifications via ManagedTaskListener
interface methods when task is:
– submitted
– not able to start or is cancelled
– about to start
– completed running, either succeeded or failed with exception
 Can be used for logging tasks progress
 Can be used for remedial actions such as resubmit a failed task
Overview

ManagedTaskListener
 ManagedTaskListener implementations typically provided by
application component
 Listeners can be associated with tasks that are submitted to
ManagedExecutorService or
 Notification methods are run in unspecified context by default
– Can be made contextual with contextual proxy object for
ManagedTaskListener

ManagedTaskListener API
 void taskSubmitted(Future<?>
future, ManagedExecutorService executor, Object
task)
 void taskStarting(Future<?>
task)
 void taskAborted(Future<?>
task, Throwable exception)
 void taskDone(Future<?>
task, Throwable exception)

Registering ManagedTaskListener
// Runnable implements ManagedTask
public class TaskWithListener implements Runnable, ManagedTask {
...
public ManagedTaskListener getManagedTaskListener() {
return aManagedTaskListener;
}
}
//use ManagedExecutors utility to associate a ManagedTaskListener to a task
Runnable aTask;
ManagedTaskListener myTaskListner;
Runnable taskWithListener =
ManagedExecutors.managedTask(aTask, myTaskListener);
...
ManagedExecutorService executor = ...;
executor.submit(taskWithListener);

ManagedTask
Overview
 Any task submitted to an ManagedExecutorService or an
ManagedScheduledExecutorService can optionally implement
ManagedTask
 Provides
– Identifying information about the task
– ManagedTaskListener for lifecycle events notification
– Any additional execution properties

ManagedTask
API
 API
– Map<String, String> getExecutionProperties()
– ManagedTaskListener getManagedTaskListener()
 Execution properties
– LONGRUNNING_HINT
– IDENTITY_NAME
– TRANSACTION
 SUSPEND
 USE_TRANSACTION_OF_EXECUTION_THREAD

ManagedExecutors
Overview
 Utility class in javax.enterprise.concurrent package
 Provided by Java EE for use by application components
 Contains methods for
– Testing whether current thread is a ManageableThread that has been
marked for shutdown
– Creating a ManagedTask that connects the given Callable/Runnable
with a given ManagedTaskListener and with any given execution
properties

ManagedExecutors
API
 public static boolean isCurrentThreadShutdown()
 public static Runnable managedTask(Runnable
task, ManagedTaskListener taskListener) throws
IllegalArgumentException
 public static Runnable managedTask(Runnable
task, Map<String,String> executionProperties, ManagedTaskListener
taskListener) throws IllegalArgumentException
 public static <V> Callable<V> managedTask(Callable<V>
task, ManagedTaskListener taskListener) throws
IllegalArgumentException
 public static <V> Callable<V> managedTask(Callable<V>
task, Map<String,String> executionProperties, ManagedTaskListener
taskListener) throws IllegalArgumentException

Program Agenda
 Overview
 Managed Objects
 Features
 Summary
 Resources

Summary
 Provides asynchronous capabilities to Java EE application
components
 Allows Java SE developers simple migration path to Java EE
 Provides managed objects to applications for submitting tasks
and obtaining managed threads
 Features such as propagation of container context
 Java EE application developers now have tools to have more
advanced control of asynchronous processing

Program Agenda
 Overview
 Managed Objects
 Features
 Summary
 Resources

Resources
 Spec and API docs
– http://jcp.org/en/jsr/detail?id=236
– http://docs.oracle.com/javaee/7/api
– http://concurrency-ee-spec.java.net
 Java EE 7 SDK
– http://www.oracle.com/javaee
 Please send feedback to
– users@concurrency-ee-spec.java.net

Graphic Section Divider

JSR 236 Concurrency Utils for EE presentation for JavaOne 2013 (CON7948)

More Related Content

What's hot (16)

Similar to JSR 236 Concurrency Utils for EE presentation for JavaOne 2013 (CON7948) (20)

Recently uploaded (20)

JSR 236 Concurrency Utils for EE presentation for JavaOne 2013 (CON7948)

Editor's Notes