jakarta - Especificación de Java EE y subprocesos múltiples

jakarta ee

Question

Estoy escribiendo una aplicación Java EE usando Struts y Spring. En una de las operaciones hay un gran procesamiento de la base de datos y, por lo tanto, problemas de rendimiento. Lo que quiero saber es si puedo usar multiproceso aquí. Creo que la especificación de Java EE no permite crear subprocesos personalizados aparte de los creados por el Servidor (uso Weblogic). Por favor guíame a través de esto.

Answer 1

Esta pregunta aparece de vez en cuando.

Según la especificación no está autorizado. La mejor página para mirar es esta: Q / A: Restricciones de J2EE

Dicho esto, hay formas de generar subprocesos, especialmente en Weblogic con el WorkManager .

Vea estas preguntas:

• ¿Cómo puede un EJB poner en paralelo un proceso largo e intensivo de CPU?
• ¿Por qué no se recomienda generar hilos en el contenedor J2EE?
• Los programadores J2EE no escriben en archivos

El hecho de que el primer objetivo de EJB no sea importante, y el último sobre el acceso al sistema de archivos tiene que ver con restricciones generales.

Espero eso ayude.

Answer 2

Estas restricciones se aplican principalmente porque Java EE y EJB desean admitir la agrupación en clúster transparente. Por ejemplo, un servidor de un clúster no debe modificar los archivos porque estos cambios no se pueden reflejar fácilmente en otros servidores. Para los subprocesos, existe la pregunta de si debería haber un subproceso por clúster o por servidor. Estos subprocesos tampoco pueden ser fácilmente monitoreados por el servidor de aplicaciones.

Dicho esto, debería ser posible crear subprocesos, conexiones de socket o acceder al sistema de archivos en un servidor Java EE como en una aplicación normal.

Answer 3

La forma recomendada de crear subprocesos en un entorno Java EE, es con la API de Utilidades de Concurrencia, que es parte de la especificación EE7.

Al usar esta API, su nuevo subproceso será creado y administrado por el contenedor, garantizando que todos los servicios de EE estén disponibles para su subproceso (por ejemplo, seguridad, transacciones).

Los ejemplos a continuación están tomados de mi propio sitio here y here

Usando un ManagedExecutorService

Para crear un nuevo hilo usando un ManagedExecutorService, primero cree un objeto de tarea que implemente Callable. Dentro del método call () definiremos el trabajo que queremos realizar en un hilo separado.

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();
}
}

Entonces necesitamos invocar la tarea pasándola al método submit () del ManagedExecutorService.

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

Usando un ManagedThreadFactory

Primero cree una tarea ejecutable que definirá qué trabajo se realizará en segundo plano.

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);
}
}
}

Para obtener un subproceso administrado por contenedor, simplemente le pedimos al ManagedThreadFactory un nuevo subproceso y le pasamos nuestra instancia de Runnable. Para iniciar el hilo llamamos a start ().

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