JavaOne 2013 San Francisco Asyn-ConcurrencyOnEE7

[ CON10982 ] Implementation of Async and Concurrent Applications in the Java EE Environment Yoshio Terada Java Evangelist http://yoshio3.com

If you have some questions,could you give me a message on Twitter with following hash tag ?

[#CON10982]My Twitter ID : @yoshioterada

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.

It is very easy to implement concurrent application on EE 7 environment. Customizable flexibly

Structure of My Sesiosn

Review of Async/Concurrencyon Java SE & Java EE6

Concurrency Utilities onJava EE 7

15-‐‑‒20 MinWith Demo

40 MinWith Demo

History of Async Application in Java

Java SEEnvironment

1996 1997

JDK1.0ThreadRunnable

20042006

JDK1.1

J2SE1.2

J2SE 1.3

J2SE 1.4

Java SE 5JSR-‐‑‒166Concurrency Utilities

Java SE 6JSR-‐‑‒166x

Hisotry of Java Thread

1998 2000 2002

・・・・・・・・

・・

・・・・・・・・

Java SE 7JSR-‐‑‒166yFork/Join

Java SE 8Lambda Expression & JSR-‐‑‒166eConcurrency Utilities

History of Java SE Thread

class MyWebServer{! public static void main(String argv[]){! ServerSocket socket = new ServerSocket(80);! while(true){! final Socket conn = socket.accept();! Runnable r = new Runnable(){! publiv void run(){ ! addConnQueue(conn);//Server opeartion 　　}};! new Thread(r).start();! }!} }!

Ex : Impl of MultiThread Web Server

Create new

Thread for

request

No more Recommend This way

new Thread(r).start();

Thread-‐‑‒1

Thread-‐‑‒2

Thread-‐‑‒3

Thread-‐‑‒n

Generated Thread Indefinitely・・・

Thread-‐‑‒1

Thread-‐‑‒2

Thread-‐‑‒3

Thread-‐‑‒n

Ex : Stack area is also allocated

スタック

Thread-‐‑‒1 Stack

Thread-‐‑‒n Stack

… …

-‐‑‒Xss

Load of Java VM and OS

Memory Consumption for each thread

UpperLimit of the number of thread creation

Overhead of the context switch

Disadvantage of unlimited thread

Java Concurrency Utilities

•  Easy API to implement concurrency application

•  Provide simple and easy API•  Scalability, Performance, Maintainability, Thread safe, easy to understand

JSR-‐‑‒166 Overview

•  Async task operation•  Concurrency Collection•  lock, synchronizer•  Atomic operation

Useful classes

•  Executors, Thread Pool, Futures •  Collection: Queues, Blocking Queues, Concurrent

HashMap•  Lock, synchronization: Semaphores, Barriers, Atomic

variable•  Others …

public interface Executor{ ! void execute(Runnable command); !} !

Executor InterfaceAsync invocation

public interface ExecutorService extends Executor{ ! void shutdown(); ! List<Runnable> shutdownNow(); ! boolean isShutdown(); ! boolean isTerminated(); ! boolean awaitTermination(long timeout,!　　　　TimeUnit unit); ! <T> Future<T> submit(Callable<T> task) ! // and more …!} !

ExecutorService InterfaceLifecycle management, get return value

static int CPU_NUM =! Runtime.getRuntime().availableProcessors();! ExecutorService pool = ! Executors.newFixedThreadPool(CPU_NUM);! public static void main(String argv[]){! ServerSocket socket = new ServerSocket(80);! while(true){! final Socket conn = socket.accept();! Runnable r = new Runnable(){! public void run(){;//do something 　　　　　} };! pool.execute(r);! }}!

WebServer implemented by Executor

newFixedThreadPool

ExecutorService execution using fixed Thread Pool

LinkedBlockingQueue (FIFO)

ThreadFactory…T1 T2 T3 T4 Tn

ExecutorService pool =!　　　Executors.newFixedThreadPool(CPU_NUM);

pool.execute(r);

•  Reuse the created Thread

•  Number of max Thread

•  Queing of incoming request

Execute Thread more Efficiently

Possible to manage the lifecycle of Thread

Benefit of Concurrency Utilities

History of Async on Java EE

JMS(MDB)Async ServletAsync EJB

J2EE 1.4

Java EE 6Async ServletAsync EJB

History of Async on Java EE

19992001

Java EE 5

J2EE 1.2JMS

J2EE 1.3MDB

JMS & MDBMore Easy : Java EE 7

Message Provider

JNDI Naming Space

ConnFactory

jms/MyConFactory

App Server Administrator

Destination

jms/MyQueue

Queue Name

Delegate the operation to External Message Provider

JNDI Name Space

ConnFactory Destination

JMS Client

Resource Injection jms/MyFactory jms/MyQueue

JMS Client connect to Message Provider via JNDI lookup

Message Provider

Queue NameDeveloper

Developer refer to the JNDI

@Stateless!public class MailAddressRegisterEJB {! @Resource(mappedName = "java:comp/JMSConFact")! ConnectionFactory conn;! @Resource(mappedName = "jms/mailRegistQueue")! Queue queue;!! public void registEmailAddress(String address){! try(JMSContext context = conn.createContext()){!　　　context.createProducer().send(queue, 　!　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　address);}}}

Send : JMS 2.0 (Java EE 7)

@MessageDriven(mappedName = "jms/mailRegistQueue")!public class SendMessageMDB implements MessageListener{! public SendMessageMDB(){}! @Inject MailSender mailSender;! @Override! public void onMessage(Message message) {! try {! TextMessage msg = (TextMessage) message;! mailSender.sendMessage(msg.getText());! } catch (JMSException jmse) {! jmse.printStackTrace();! }! }}

Receive: MDB (Java EE 7)

Servlet 3.0 : since Java EE 6(asyncSupported = true)

@WebServlet(name = "MailSenderServlet", ! urlPatterns = {"/MailSenderServlet"}, ! asyncSupported = true)!public class MailSenderServlet extends HttpServlet {!! protected void processRequest(! HttpServletRequest request, ! HttpServletResponse response)! throws ServletException, IOException {! AsyncContext ac = request.startAsync();! ac.start(new MailSenderRunnable(ac));! }}!

Servlet 3.0 : Async Servlet

EJB 3.1 : since Java EE 6@Asynchronous

@Stateless!public class SyncEmailSenderEJB {! @Inject! MailSender mailsend;! public void syncSendMessage(String email){! mailsend.sendMessage(email);! }!! @Asynchronous! public void asyncSendMessage(String email){! mailsend.sendMessage(email);! }}!

EJB 3.1 (Java EE 6)

Concurrency Utilities for EE

Application Servers

Java SE

Web/EJB Container

EJB JSP

Servlet

Runnable

CallableOther Java EE functionality (JAX-‐‑‒RS,JavaMail, CDI, etc)

Not recommended to create Threadon Java EE environment.

Thread run outside of the Container

Application Servers

Java SE

Web/EJB Container

EJB JSP

Servlet

Runnable

Callable

Concurrency Architecture on EE 7

Other Java EE function(JAX-‐‑‒RS,JavaMail, CDI, etc)

ManagedExecutor ServiceManagedScheduledExecutorServiceContextServiceManagedThreadFactoryConcurrency Utilities for EE

It is easy to implement !!

It is possible to Customize !!

Small Package : Total 12 class

Usecase senario?

For long running process

Effective use of hardware!

For executing regularly

Usecase senario

Would like to run a Task on Java EE

environmentWhich is implemented

on Java SE

environment.

Important Interfaces

Best 4

• ManagedExecutorService

• ManagedScheduledExecutorService

• ManagedThreadFactory

• ContextService

Easy development To create Async Task(ManagedExecutorService)

Memo Most easy way !!

Implements some Task

A implements RunnableB implements Callable

Implement Async Task

Use the configured managed Thread by resource Injection

Configure Server side

Possible to use the default configuration

１２

Step to create Async Task

public class MyRunnableTask implements Runnable {! @Override! public void run() { ! try {! Thread.sleep(10000); //do Something } catch (InterruptedException ex) {! logger.log(Level.SEVERE, null, ex);! }! }!}!

Implement Runnable Task１

Implement Callable Task 　　　　● Possible to get the return value 　　　　● Possible to throw the Exception

public class MyCallableTask implements ! Callable<String> {! @Override! public String call() throws Exception {! return “Hello World”;! }!}!

Configuration on Server Side２

@Stateless!public class MyManagedExecutorService {! @Resource(name = ! "concurrent/DefaultManagedExecutorService")! ManagedExecutorService managedExecsvc; ! public void execExecutorService() {! MyRunnableTask task = new MyRunnableTask();! managedExecsvc.submit(task);!　　　　　 MyCallableTask singleTask = !　　　　　　　　　　new MyCallableTask("Foo Bar");! Future<String> singleFuture = 　　 ! managedExecsvc.submit(singleTask);}!

Exec Async Task on EJB３

Inject the resource

Scheduling the Async Task(ManagedScheduledExecutorService)

Implement the Task

A implements RunnableB implements Callable

Implement Async Task

Use the configured managed Thread by resource Injection

Configure on Server Side

Possible to use default configuration

１２

Scheduling Async Task Impl

Server Side Configuration２

@Stateless!public class MyManagedScheduledExecutorService{! @Resource(name = "concurrent/! DefaultManagedScheduledExecutorService")! ManagedScheduledExecutorService managedScheduledExecsvc;!! public void execScheduledExecutorService() {! MyRunnableTask task = new MyRunnableTask();! managedScheduledExecsvc.schedule(! task, 60L, TimeUnit.SECONDS);! }!

Exec Async Scheduled Task３

Exec TaskAfter 1 min.

@Stateless!public class MyManagedScheduledExecutorService{! @Resource(name = "concurrent/! DefaultManagedScheduledExecutorService")! ManagedScheduledExecutorService managedScheduledExecsvc;!! public void execScheduledExecutorService() {! MyRunnableTask task = new MyRunnableTask();! managedScheduledExecsvc.schedule(! task, new MyTrigger(new Date(), 10, 1000) }!

You can Implement own trigger

Exec Async Scheduled Task３

import javax.enterprise.concurrent.Trigger;!public class MyTrigger implements Trigger {!! @Override! public Date getNextRunTime(LastExecution le, ! Date date){! }!! @Override! public boolean skipRun(LastExecution le, ! Date date) {!! }!}! On Trigger you can i

mplement

The next run time and/or skip

Management and Monitoringof Task Lifecycle

Lifecycle of Task

taskSubmitted Submitted taskStarting

taskAborted Started

taskDone

submit() submitsuccess

Cancel or Abort

About to Start

Running Task

Cancelled or aborted Task has finished

Task Monitoring

　　: can write

Rejected

public class MyManagedTaskListener implements ! ManagedTaskListener {! public void taskSubmitted(Future<?> future, ! ManagedExecutorService mes, Object o) {! }! public void taskStarting(Future<?> future, ! ManagedExecutorService mes, Object o) {! }! public void taskAborted(Future<?> future, ! ManagedExecutorService mes, Object o, Throwable thrwbl){! }! public void taskDone(Future<?> future, ! ManagedExecutorService mes, Object o, Throwable thrwbl){! }!}!

Create own Task Listener

which is implemented by

ManagedTaskListener

@Resource(name = "concurrent/! MyManagedExecutorService")!ManagedExecutorService manageExecsvc;!!public void invokeMyTaskListener() {! MyRunnableTask task = new MyRunnableTask();! MyManagedTaskListener listener = ! new MyManagedTaskListener();! Runnable taskWithListener = ! ManagedExecutors.managedTask(task, listener);! manageExecsvc.execute(taskWithListener);!}!

Detail of Internal BehaviorContextSerivce

ManagedExecutorService

ManagedScheduledExecutorService

We can understand :

it is very easy to implement the concurrent t

by Resource Injection.

We can manage the lifecycle of tasks.

How to run the concurrent

tasks internally ?

MemoInternally :

Use “Dynamic Proxy” and

add some context informations

Do you remember

Dynamic Proxy ?

(java.lang.reflect.Proxy)

Method Invocation by Dynamic Proxypublic class MyRunnable implements Runnable{! @Override! public void run() {!　　　System.out.println(“Original Method Invoke");!　　}!}

This Task will be executed via

Dynamic Proxy

Implement of own InvocationHandler

public class MyInvocationHandler implements InvocationHandler {! private Object underlying;! public MyInvocationHandler(Object underlying) {! this.underlying = underlying;! }!

@Override!public Object invoke(Object proxy, Method method, !　　　　　　　　　　　　　Object[] args) throws Throwable {! System.out.println(”Pre Invoke of orign method");! Object ret = method.invoke(underlying, args);! System.out.println(“Post Invoke of orign method");! return ret;}!}

Execute the Task via Dynamic Proxy

public class MyDynamicProxy {! public static void main(String argv[]){!　　 //… create proxied Task here!}}!

MyRunnable task = new MyRunnable();!InvocationHandler handler = new !　　　　　　　　　　　　　　　　　　　MyInvocationHandler(task);!Runnable proxy = !　　　　(Runnable)Proxy.newProxyInstance(!　　　　　　　MyRunnable.class.getClassLoader(), !　　　　　　　new Class[]{Runnable.class}, handler);!ExecutorService exec = !　　　　　　　　　　　Executors.newSingleThreadExecutor();!exec.submit(proxy);

Result of execute Task via Dynamic Proxy

Pre Invoke of orign methodOriginal Method InvokePost Invoke of orign method

ExecutorService exec = 　! Executors.newSingleThreadExecutor();!exec.submit(proxy);!

Useful for AOP

InvocationHandler is

implemented by App Server

* GlassFish v4.0

　　org.glassfish.enterprise.concurrent.inter

　　ContextProxyInvocationHandler

Configuration on ServerSide1

@Stateless!public class ContextServiceManager {! @Resource(name = "concurrent/DefaultContextService")! ContextService ctxSvc;!!　　public void execSimpleContextService() {! ExecutorService singleThreadExecutor = ! Executors.newSingleThreadExecutor(threadFactory);! MyRunnableTask task = new MyRunnableTask();! Runnable proxiedTask =! ctxSvc.createContextualProxy(task,Runnable.class);! singleThreadExecutor.submit(proxiedTask);}}! !

CreateDynamic Proxy

Task Execution with Context2

Original Task

Task which is created byDynamic Proxy

It is possible to run the Task on EE with Context.

Detail of Internal BehaviorThreadFactory

Memo • we can implement custom managed thread

pool on the program side not server side

and can execute from the created pool.

※ It is possible to customize the way to

create a Thread by program.

Configuration on ServerSide1

@Resource(name = "concurrent/! DefaultManagedThreadFactory")!ManagedThreadFactory threadFactory;!public void execThreadFactory() {! MyRunnableTask task = new MyRunnableTask();! Thread taskThread = ! threadFactory.newThread(task);! taskThread.start();!}!

Create Thread via ThreadFactory（It is for long running process）

Simple

ExecutorService threadPoolExecutor = ! Executors.newFixedThreadPool(4,threadFac);!!!threadPoolExecutor = new ThreadPoolExecutor(4, 4,!　　　　　　　　　　　　　　　　　　　　0L, TimeUnit.MILLISECONDS,!　　　　　　　　　　　　　　　　　　　　new LinkedBlockingQueue<Runnable>(),　!　　　　　　　　　　　　　　　　　　　　threadFac);!

It is possible to create custom Thread Pool by using ThreadPoolExecutor

Above two code is same

java.util.concurrent.ThreadPoolExecutor

@Resource(name = "concurrent/! DefaultManagedThreadFactory")!ManagedThreadFactory threadFactory;!public void execThreadFactory() {!　　MyRunnableTask task = new MyRunnableTask();!　　ExecutorService exec = !　　　　　　　　　　　new ThreadPoolExecutor(4, 4,!　　　　　　　　　　　0L, TimeUnit.MILLISECONDS,! new　LinkedBlockingQueue<Runnable>(),　!　　　　　　　　　　　threadFactory);!　　exec.submit(task);}!

Create new Thread from Custom Thread Pool

Finally

Restriction :

We can use with CDI only for

@ApplicationScoped

@Dependent

Note : Lifecycle of CDI

Restriction

You canʼ’t use on Application

Client Container

Restriction

We canʼ’t use with

Fork/Join (ForkJoinPool).

Restriction

We canʼ’t invoke lifecycle method of

ExecutorService.

(ex. shutdown, shutdownNow)

※ ManagedExecutorService

※ ManagedScheduledExecutorService

ConclusionEffective use of computer assets 　　from Async to Concurrent

Safe and easy way to create the thread on Java EE environment

Flexible customization

Related Session[CON7948] : JSR 236: Introduction to Concurrency Utilities for Java EE 1.0

Thursday, Sep 26, 12:30 PM -‐‑‒ 1:30 PM Parc 55 -‐‑‒ Cyril Magnin I

Anthony Lai – Oracle (Spec Lead)Fred Rowe – IBM

Resource

Sample Source Code 　　　　https://github.com/yoshioterada/ 　　　　　　　　　　　　　　　　ConcurrentUtil4EE

JSR 236 Related Page 　　　　http://jcp.org/en/jsr/detail?id=236 　　　　https://java.net/projects/ 　　　　　　　　　　　　　　　concurrency-‐‑‒ee-‐‑‒spec

Graphic Section Divider

JavaOne 2013 San Francisco Asyn-ConcurrencyOnEE7

Technology

Transcript of JavaOne 2013 San Francisco Asyn-ConcurrencyOnEE7

Duchess JavaOne 2011

asyn Training EPICS Collaboration Meeting April 2012

Spring ME JavaOne

VRaptor 4 - JavaOne

Asyn Sync Transmission

asyn: An Interface Between EPICS Drivers and Clients

DataFX - JavaOne 2013

Project Zero JavaOne 2008

Ankor Presentation @ JavaOne San Francisco September 2014

asyn: An Interface Between EPICS Drivers and Device Support

JavaOne 2007 BOF Session

Srr tuayon asyn (1)

DataFX 8 (JavaOne 2014)

JavaOne 2003, San Francisco 10.-13.6.2003

ASYN Profile-new( 93-06-08)

JavaFX JumpStart @JavaOne 2016

JavaOne 2003, San Francisco 10.-13.6.2003 java.sun/javaone

JavaFX Enterprise (JavaOne 2014)

JavaOne 2012, San Francisco Reach the Next Billion with ...docs.huihoo.com/javaone/2012/BOF12804-Reach-the-Next-Billion-with... · Reach the Next Billion with Engaging Apps: Full

USING ASYN CHRONOUS DIS CUSSIONS TO FACILITATE ...