Think async

Think Async
Bhakti Mehta
Twitter: @bhakti_mehta
Copyright 2013, Bhakti Mehta all rights reserved

Introduction
• Currently working as a Senior Software Engineer
at Blue Jeans Network. Bluejeans.com
• Worked at Sun Microsystems/Oracle for 13 years
• Committer to numerous open source projects
including GlassFish

My upcoming book

What you will learn
• Start thinking asynchronously
• Cover different technologies with respect to async
support
• Cover concepts from J2SE and J2EE with respect
to asynchronous processing

Why Think Async?
• Increase speed of processing through
parallelization
• Involve multiple CPU cores for processing than
single fast CPU
• Compare with older request response models and
see the benefits

Where async can be
used?
• Long running operations
• Processor intensive tasks
• Background tasks
• To improve application throughput
• To improve application response time

Usecases
• User John Doe wants to download multiple files
from different locations.
Solution
• Execute requests asynchronously and wait for
results from Future object

Usecases
• Use John Doe has a large data to post to a URL
Solution
Use callbacks instead of waiting and blocking for
response

Usecases
• Use John Doe want to upload a large file
Solution
Use AsynchronousFileChannel from JDK 7

Polling
• Polling
 Used by vast majority of AJAX applications
 Poll the server for data
 Client --->request--> Server
 If no data empty response is returned
 Not a true asynchronous mechanism

Polling
Request (client_id)
Response 200 OK: empty
Request (client_id)
….
….
….
….
Response 200 OK: message
body

Polling Drawbacks
 Http overhead
 Reducing the interval will consume more
bandwidth and processing resources for nothing.

Long Polling
 If server does not have data holds request open
 COMET
 Chunked transfer encoding can be used to send
chunks of data as part of response body which is
opened as a stream.
 Chunks can be javascript tags loaded in hidden
iframe and executed in order of arrival

Long Polling
Request (client_id)
body
Request (client_id)
….
….
….
body
….
….

Long Polling Drawbacks
• No standard data format or message format when
used in chunked transfer encoding mode
• Each connection initiation has the initiation cost.
• No caching between clients and server, which
impacts the server performance instead of reading
some contents from the cache.

Server-sent Events
 Unidirectional channel between server and client
 Server pushes data to your app when it wants
asynchronously
 Updates can be streamed from server to client as
they happen

Server-sent Events
Request (client_id)
….
….
….
SSE message
….
….
SSE message

WebSockets
 Next generation of asynchronous communication
from client to server
 Full duplex communication in either direction
 After initial handshake on http communication is
over TCP socket using ws(unsecure) or
wss(secure) protocol

WebSocket Handshake
Client and Server upgrade from Http protocol to WebSocket protocol during initial handshake
GET /text HTTP/1.1rn
Upgrade: WebSocketrn
Connection: Upgradern
Host: www.websocket.orgrn …rn
Handshake from server looks like
HTTP/1.1 101 WebSocket Protocol Handshakern
Upgrade: WebSocketrn
Connection: Upgradern …rn

WebSockets
 After the upgrade HTTP is completely out of the
picture at this point.
 Using the lightweight WebSocket wire protocol,
messages can now be sent or received by either
endpoint at any time.
 Creating a Websocket
 ws = new WebSocket("ws://localhost:8080/../WebSocketChat");
 You can set handlers for events onopen or onerror

Other JavaEE technologies
Async support
• Servlet 3.0
• JAX-RS
• EJB

Components ofAsyncServlet
• New attribute asyncSupported on @WebServlet annotation
or in web.xml
• AsyncContext
• Thread Pool
• Runnable instance

AsyncServlet
• When asyncSupported attribute is set to true
response is not committed on method exit
• Calling startAsync() method of AsyncContext
caches the request response pair
• The method returns and original thread is recycled
• AsyncListener and AsyncEvent give developers
control of the asynchronous lifecycle events

AsyncServlet
final AsyncContext asyncContext = request.startAsync();
asyncContext.setTimeout(600000);
asyncContext.addListener(new AsyncListener()
Implement the following method of the AsyncListener
onComplete(), onError(),OnTimeout(), onstartAsync()

Servlet 3.1:Non blocking IO
• ReadListener
• WriteListener
• These are then registered using
ServletInputStream.setReadListener and
ServletOutputStream.setWriteListener. The
listeners have callback methods that are invoked
when the content is available to be read or can be
written without blocking.

Servlet 3.1: Non blocking IO
public interface ReadListener extends EventListener {
public void onDataAvailable(ServletRequest request);
public void onAllDataRead(ServletRequest request);
public void onError(Throwable t);
}

• The onDataAvailable: Invoked when all data for
the current request has been read.
• The onAllDataRead: Method is invoked by the
container the first time when it is possible to read
data.
• The onError: Invoked when an error occurs
processing the request

public interface WriteListener extends EventListener {
public void onWritePossible(ServletResponse response);
public void onError(Throwable t);
}

• The container invokes the onWritePossible
method when it is possible to write in the Servlet’s
OutputStream.
• The onError is invoked when writing in the
Servlet’s OutputStream encounters an exception.

ServletOutputStream
• In the ServletOutputStream interface
• isReady: This method can be used to determine
if data can be written without blocking.
• setWriteListener: Instructs the
ServletOutputStream to invoke the provided
WriteListener when it is possible to write

ServletInputStream
• In the ServletInputStream interface
• isFinished: Returns true when all the data from
the stream has been read else it returns false.
• isReady: Returns true if data can be read
without blocking else returns false.
• setReadListener: Instructs the
ServletInputStream to invoke the provided
ReadListener when it is possible to read

JAX-RS 2.0 Async
support
• Server Side
• Client Side

JAX-RS 2.0 Server
sideAsync support
• AsyncResponse: An injectable JAX-RS
asynchronous response that provides means for
asynchronous server side response processing.
• @Suspended: The @Suspended instructs the
container that the HTTP request processing should
happen in a secondary thread.
• CompletionCallback: A request processing callback
that receives request processing completion events.
Has onComplete() callback
• ConnectionCallback: Asynchronous request
processing lifecycle callback that receives
connection related asynchronous response lifecycle
events.

JAX-RS 2.0 Server
sideAsync support
• InvocationCallback: Callback that can be
implemented to receive the asynchronous
processing events from the invocation
processing.
• Future: Allows the client to poll for completion of
the asynchronous operation or to block and wait
for it.

@Suspended
@Path(“/books/borrow”)
@Stateless
public class BookResource {
@GET @Produce(“text/plain”)
@Asynchronous
public void borrow(@Suspended AsyncResponse ar) { final String result = prepareResponse();
ar.resume(result) }
}

Client side code
Future<Book> future = client.target("(“books/borrow/borrow")
.request()
.async()
.get(Book.class);
try {
Book book = future.get(30, TimeUnit.SECONDS);
} catch (TimeoutException ex) {
System.err.println("Timeout occurred");
}

InvocationCallback
sample
client.target(restUrl)
.request(MediaType.APPLICATION_JSON)
.async()
.post(Entity.entity("Here is some text", MediaType.TEXT_PLAIN),
new InvocationCallback<Response>() {
@Override
public void completed(Response response) {
processResponse(response.readEntity(JSONObject.class));
}

EJB 3.1
• @Asynchronous annotation introduced in EJB 3.1
• Methods annotated with @Asynchronous will
return immediately regardless of how long the
method usually takes.
• Each invocation returns a Future object which is
initially empty and will have its value filled later
when method completes

AsyncResult
• AsyncResult<V> wraps the result of an
asynchronous method call as a Future object
• The value specified in the constructor
AsyncResult(V result) will be retrieved by
Container and sent to client.

Cancelling an async
invocation
• The session bean can check whether the client
requested that the invocation be cancelled by
calling
the javax.ejb.SessionContext.wasCancelled().

@Asynchronous code
snippet@Path(“/books/borrow”)
@Stateless
public class BookResource {
@Context private ExecutionContext ctx;
@GET @Produce(“application/json”)
@Asynchronous
public void borrow() {
Executors.newSingleThreadExecutor().submit( new Runnable() {
public void run() {
Thread.sleep(10000);
ctx.resume(“Hello async world!”);
} });
ctx.suspend();
return; }} Copyright 2013, Bhakti Mehta all rights reserved

Java SE and Think Async
• Future
• A Future object represents the result of
asynchronous completion.
• Methods to check if computation is complete, wait
for result and retrieve results.
• Cancellation can be performed by cancel method

AsynchronousFileChannel
try (AsynchronousFileChannel asyncChannel = AsynchronousFileChannel.open(path)){
//Returns a Future instance which can be used to read the contents of the
file.
Future<Integer> fileResult = asyncChannel.read(buffer, 0);
while(!fileResult.isDone()){
System.out.println("Waiting to complete the file reading ...");
}

Call for action
• Download GlassFish 4.0 from
glassfish.dev.java.net for latest JavaEE7 API
• File issues, contribute patches
• Email users@glassfish.dev.java.net

Questions
• Twitter: @bhakti_mehta
• Blog https://www.java.net//blogs/bhaktimehta
• LinkedIn: http://www.linkedin.com/in/bhaktihmehta
• Slideshttp://www.slideshare.net/bhaktiks/think-async

Think async

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (19)

Destaque

Destaque (16)

Semelhante a Think async

Semelhante a Think async (20)

Último

Último (20)

Think async

Notas do Editor