Concurrency Utilities in JavaEE with TomEE?

JavaEE 7 is just out but it already makes a lot of noise! One interesting thing is the JSR 236 (aka Concurrency Utilities for JavaEE). It is basically the specification of what everybody was already doing: using “multi-threading” in JavaEE.

While TomEE still targets JavaEE 6 (hopefully it will target JavaEE 7 after the 1.6.0 release) it can’t be integrated directly in the server. However with a little tip you can already play with it!

Reminder: what is the JSR 236

What do you need to write a concurrent program: some threads, some synchronization, not really more in fact for basic cases (for complex cases you’ll surely want to use JBatch).

What do we have in the JVM itself? ExecutorService and ScheduledExecutorService for the multi-threading. Latch, Locks and “children” for the synchronization. So what is missing?

First it was not allowed by all specifications to play with threading (basically because implementations was very linked to ThreadLocal). Then if your container lets you start threads then you are no more managed. It means you loose the security context, the caller context (if in an ejb it can be a big issue), the caller classloader etc…

If sometimes that’s not an issue you are quickly limited in the interactions you can get with the container. This is mainly what the JSR 236 solves providing a ManagedExecutorService (same for scheduled version) which ensures you the threads are “managed” by the container.

Hello World

Here is a basic application using this new API:

package org.cuee;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
import javax.ejb.Lock;
import javax.ejb.LockType;
import javax.ejb.Singleton;
import javax.ejb.Startup;
import javax.enterprise.concurrent.ManagedScheduledExecutorService;
import java.util.Date;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

@Singleton
@Startup
@Lock(LockType.READ)
public class DatePrinter {
    @Resource
    private ManagedScheduledExecutorService ses;

    private ScheduledFuture<?> future;

    @PostConstruct
    public void start() {
        future = ses.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("Date: " + new Date());
            }
        }, 0, 1000, TimeUnit.MILLISECONDS);
    }

    @PreDestroy
    public void stop() {
        future.cancel(true);
    }
}

The API is known since that’s the same as the JRE one but the type (prefixed with “managed”) ensures you execute your tasks in a JavaEE environment.

Side note: the scheduled executor service version got two new methods (one for Runnable tasks and one for Callable ones). These methods rely on a Trigger to compute runs. It is the generalization of scheduleAtFixedRate method allowing you to schedule task with dynamic rates.

How to test it in TomEE?

To test it with the TomEE the easier is to use the tomee maven plugin to add the javax.enterprise.concurrent-api jar and the implementation (openejb-concurrency-utilities-ee).

Here is a sample configuration (think to add apache snapshot repository to your pom):

<plugin>
  <groupId>org.apache.openejb.maven</groupId>
  <artifactId>tomee-maven-plugin</artifactId>
  <version>1.6.0-SNAPSHOT</version>
  <configuration>
    <libs>
      <lib>javax.enterprise.concurrent:javax.enterprise.concurrent-api:1.0</lib>
      <lib>org.apache.openejb:openejb-concurrency-utilities-ee:4.6.0-SNAPSHOT</lib>
    </libs>

    <!-- these 2 lines are not mandatory but makes the dev cooler -->
    <simpleLog>true</simpleLog>
    <context>ROOT</context>
  </configuration>
</plugin>

Think to add as provided the concurrent-api jar to be able to use its types:

<dependency>
  <groupId>javax.enterprise.concurrent</groupId>
  <artifactId>javax.enterprise.concurrent-api</artifactId>
  <version>1.0</version>
  <scope>provided</scope>
</dependency>

Then just compile your war project and run it (mvn tomee:run).

Advertisement