Especificación Java EE y multi threading

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 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.

Answer 1

Esta pregunta aparece de vez en cuando.

Según la especificación no está autorizado. La mejor página para tener en cuenta es la siguiente: Q/A: J2EE Restrictions

Dicho esto, hay maneras para desovar hilos, especiall en Weblogic con el WorkManager.

ver estas preguntas:

• 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

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

Espero que ayude.

Answer 2

Estas restricciones se aplican 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.

Answer 3

La manera 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 ejemplos siguientes se toman de mi propio sitio here y here

El uso de un ManagedExecutorService

Para crear un nuevo hilo usando una ManagedExecutorService, en primer lugar crear un objeto que implementa la tarea rescatable. Dentro del método call() definiremos el trabajo que queremos llevar a cabo 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 tenemos que invocar la tarea pasándolo a pesar de que el método submit() de la ManagedExecutorService.

@Stateless 
public class ReportBean { 

    @Resource 
    private ManagedExecutorService executorService; 

    public void runReports() { 
     ReportTask reportTask = new ReportTask(); 
     Future<Report> future = executorService.submit(reportTask); 
    } 
} 

El uso de un ManagedThreadFactory

En primer lugar crear una tarea Ejecutable que va a definir lo que el trabajo que se debe hacer en el fondo.

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 contenedor administrado, simplemente solicitamos la ManagedThreadFactory para un nuevo hilo, y la pasamos nuestra instancia Ejecutable. 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(); 
    } 
}