Java EE specification and multi threading

The recommended way to create threads in a Java EE environment, is with the Concurrency Utils API, which is part of the EE7 specification.

By using this API your new thread will be created, and managed by the container, guaranteeing that all EE services are available to your thread (eg security, transactions).

The examples below are taken from my own site here and here

Using a ManagedExecutorService

To create a new thread using a ManagedExecutorService, first create a task object that implements Callable. Within the call() method we will define the work that we want carried out in a separate thread.

public class ReportTask implements Callable<Report> {    Logger logger = Logger.getLogger(getClass().getSimpleName());    public Report call() {        try {            Thread.sleep(3000);        catch (InterruptedException e) {            logger.log(Level.SEVERE, "Thread interrupted", e);        }        return new Report();    }}

Then we need to invoke the task by passing it though to the submit() method of the ManagedExecutorService.

@Statelesspublic class ReportBean {    @Resource    private ManagedExecutorService executorService;    public void runReports() {        ReportTask reportTask = new ReportTask();        Future<Report> future = executorService.submit(reportTask);    }}

Using a ManagedThreadFactory

First create a Runnable task which will define what work is to be done in the background.

public class ReportTask implements Runnable {    Logger logger = Logger.getLogger(getClass().getSimpleName());    public void run() {        try {            //do your background task            Thread.sleep(10000);        } catch (InterruptedException e) {            logger.log(Level.SEVERE, "Thread interrupted", e);        }    }}

To get a container managed thread, we simply ask the ManagedThreadFactory for a new thread, and pass it our Runnable instance. To start the thread we call start().

@Statelesspublic class ReportBean {    @Resource    private ManagedThreadFactory threadFactory;    public void runReports() {        ReportTask reportTask = new ReportTask();        Thread thread = threadFactory.newThread(reportTask);        thread.start();    }}

This question pops up once in a while.

As per the spec it's not authorized. The best page to look at is this one: Q/A: J2EE Restrictions

That said, there are ways to spawn threads, especiall in Weblogic with the WorkManager.

See these questions:

• How can an EJB parallelize a long, CPU intensive process?
• Why spawning threads in J2EE container is discouraged?
• J2EE programmers do not write to files

The fact that the first one targets EJB shouldn't matter that much, and the last one about access to file system is about general restrictions.

Hope it helps.

These restrictions are in place mostly because Java EE and EJB want to support transparent clustering. For example one server of a cluster should not modify files because these changes can not be easily mirrored to other servers. For threads there is the question if there should be one thread per cluster or per server. These threads also can not be easily monitored by the application server.

That said, it should be possible to create threads, socket connections or access the filesystem in a Java EE server just like in a normal application.