In recent Jersey release 2.x, there is a new API for async request processing. It includes an excellent example server-async-standalone-webapp.
In this article, I'll show how to run it and the results we can get by leveraging async processing.
First, we need to download Glassfish 4.1 Web profile (https://glassfish.java.net/download.html).
Then start it using command:
./asadmin start-domain
Next, we need to download Jersey examples bundle from https://jersey.java.net/download.html and compile server-async-standalone example by running 'mvn package'.
Then we can deploy it using following command:
./asadmin deploy <path>/jersey/examples/server-async-standalone/webapp/target/server-async-standalone-webapp.war
Now we are ready to login to Glassfish Admin Console (localhost 4848) and see the status of deployed application:
Now we're ready to run a client GUI application, which allows us to run tests against server. Go to 'server-async-standalone/client' and run 'mvn exec:java'.
The application looks like below. I ran sync vs async test on 100 requests and got response times improved from 20 secs to 1.2 secs.
 |
| Sync |
 |
| Async |
The code is following for sync:
@GET
@Path("sync/{echo}")
public String syncEcho(@PathParam("echo") final String echo) {
try {
Thread.sleep(SLEEP_TIME_IN_MILLIS);
} catch (final InterruptedException ex) {
throw new ServiceUnavailableException();
}
return echo;
}
And for async:
private static final ExecutorService TASK_EXECUTOR = Executors.newCachedThreadPool();
...
@GET
@Path("async/{echo}")
public void asyncEcho(@PathParam("echo") final String echo, @Suspended final AsyncResponse ar) {
TASK_EXECUTOR.submit(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(SLEEP_TIME_IN_MILLIS);
} catch (final InterruptedException ex) {
ar.cancel();
}
ar.resume(echo);
}
});
}
In Sync mode, the threads hold http executor. The default number of http worker threads in Glassfish is 5. This explains why we get response time around 20 secs for 100 requests.
"http-listener-1(4)" daemon prio=6 tid=0x000000000cc7d000 nid=0xcf8 waiting on condition [0x00000000110ad000]
java.lang.Thread.State: TIMED_WAITING (sleeping)
at java.lang.Thread.sleep(Native Method)
at org.glassfish.jersey.examples.server.async.LongRunningEchoResource.syncEcho(LongRunningEchoResource.java:77)
at sun.reflect.GeneratedMethodAccessor437.invoke(Unknown Source)
...
Note that this is just an example, which illustrates how to enable Async processing. In real world scenarios there can be a third party service, which can be invoked using Jersey Client on the server side. If that service slows down, then the whole http thread pool on the server side can be exhausted and prevent other requests from getting processed.
The suggested solution in this case would be to switch to Async Jersey Client and Async service implementation.
Async server processing can also help in case where there is a lot of slow clients. For example 20k mobile clients, who send payloads in chunks with 1 second delays. This scenario can easily bring down Sync server side implementations.
Async processing is gaining momentum on server side nowadays. There are multiple technologies,
which enable it. Among them are NodeJS, Netty, Akka and Play Framework. Jersey Async processing is one of them.
