Especificación Java EE y multi threading

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 multihilo aquí? Creo que la especificación Java EE no permite la creación de subprocesos personalizados aparte de los creados por el Servidor (yo uso Weblogic). Por favor, guíame a través de esto.

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 J2EE

Dicho esto, hay formas de engendrar hilos, especialmente en Weblogic con el WorkManager .

Vea estas preguntas:

  • ¿Cómo puede un EJB paralelizar un proceso largo, intensivo de CPU?
  • ¿Por qué se desalientan los hilos de desove en el contenedor J2EE?
  • Los progtwigdores J2EE no escriben en archivos

El hecho de que el primero se dirija a EJB no debería importar mucho, y el último sobre el acceso al sistema de archivos se trata de restricciones generales.

Espero eso ayude.

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

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

Los siguientes ejemplos están tomados de mi propio sitio aquí y aquí

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 llevar a cabo en un hilo separado.

 public class ReportTask implements Callable { 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(); } } 

Luego, debemos 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 future = executorService.submit(reportTask); } } 

Usando una ManagedThreadFactory

Primero crea una tarea Runnable que definirá qué trabajo se debe hacer 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 hilo administrado por contenedor, simplemente le pedimos a ManagedThreadFactory un nuevo hilo, 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(); } } 

Estas restricciones están vigentes principalmente porque Java EE y EJB desean admitir clusters transparentes. Por ejemplo, un servidor de un clúster no debe modificar archivos porque estos cambios no pueden reflejarse fácilmente en otros servidores. Para los hilos existe la pregunta si debe haber un hilo por clúster o por servidor. Estos subprocesos tampoco pueden ser monitoreados fácilmente 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.