Gestores de trabajo

Un gestor de trabajo proporciona hebras para las aplicaciones Java™ Platform, Enterprise Edition (Java EE).

Con la consola administrativa, el administrador puede configurar el número que desee de gestores de trabajos. El administrador especifica las propiedades del gestor de trabajos, incluida la política de herencia de contexto de Java EE para tareas enviadas al gestor de trabajo. El administrador enlaza cada uno de los gestores de trabajos con una ubicación exclusiva en JNDI (Java Naming and Directory Interface). Puede utilizar los objetos de gestor de trabajo en cualquiera de las interfaces siguientes:
  • Ejecutores gestionados
    • javax.enterprise.concurrent.ManagedExecutorService
    • javax.enterprise.concurrent.ManagedScheduledExecutorService
    • java.util.concurrent.ExecutorService
    • java.util.concurrent.ScheduledExecutorService
  • Fábricas de hebras
    • javax.enterprise.concurrent.ManagedThreadFactory
    • java.util.concurrent.ThreadFactory
  • Servicio de contexto de hebras
    • javax.enterprise.concurrent.ContextService
  • Beans asíncronos
    • com.ibm.websphere.asynchbeans.WorkManager
  • Gestor de trabajo CommonJ
    • commonj.work.WorkManager
El tipo de interfaz seleccionado se resuelve durante el tiempo de búsqueda JNDI basándose en el valor que se especifique en la referencia de entorno de recursos.

Los gestores de trabajo proporcionan un modelo de programación para las aplicaciones Java EE. Si desea más información, consulte la sección sobre el modelo de programación.

Avoid trouble Avoid trouble: La clase javax.resource.spi.work.WorkManager es una interfaz Java que utilizarán los adaptadores de recursos JCA (Java EE Connector Architecture). No es una implementación real de WorkManager utilizado por las aplicaciones Java EE. gotcha

Al escribir un componente web o de Enterprise JavaBeans (EJB) que utiliza beans asíncronos, el desarrollador debe incluir una referencia de entorno de recurso en cada componente que necesite acceso a un gestor de trabajo. Para obtener más información sobre las referencias de recursos, consulte el tema Referencias. El componente consulta un ejecutor de trabajos, fábrica de hebras, servicio de contexto o gestor de trabajo que utiliza un nombre lógico en el componente, espacio de nombres java:comp, del mismo modo que consulta un origen de datos, un enterprise bean o una fábrica de conexiones.

El desplegador enlaza gestores de trabajo físicos con referencias de entorno de recursos lógicos (ejecutores gestionados, fábricas de hebras, servicios de contexto o gestores de trabajo) cuando se despliega la aplicación.

Por ejemplo, si un desarrollador necesita tres agrupaciones de hebras para particionar el trabajo en los niveles bronce, plata y oro, el desarrollador graba el componente para que elija una agrupación lógica a partir de un atributo del perfil de la aplicación cliente. El desplegador tiene flexibilidad para decidir cómo desea correlacionar esta solicitud para tres agrupaciones de hebras. El desplegador puede decidir utilizar una sola agrupación de hebras en un sistema pequeño. En este caso, el desplegador enlaza las tres referencias de recursos con la misma instancia de gestor de trabajos (es decir el mismo nombre JNDI). Un sistema más potente permite tres agrupaciones de hebras, por lo que el desplegador enlaza cada referencia de recursos con un gestor de trabajo diferente. Los gestores de trabajo se pueden compartir entre varias aplicaciones Java EE instaladas en el mismo servidor.

Un desarrollador de aplicaciones puede utilizar tantas referencias de entornos de recursos lógicos como sea necesario. El desplegador elige si desea correlacionar uno o varios gestores de trabajo físicos con el ejecutor, la fábrica de hebras, el servicio de contexto el gestor de trabajo lógico gestionado que se ha definido en la aplicación.

Todos los componentes Java EE que necesiten compartir objetos de ámbito asíncrono deben utilizar el mismo gestor de trabajo. Estos objetos de ámbito tienen afinidad con un único gestor de trabajo. Una aplicación que utilice ámbitos asíncronos debe verificar que todos los componentes que utilizan objetos de ámbito utilicen el mismo gestor de trabajo.

Cuando se definen varios gestores de trabajo, las agrupaciones de hebras subyacentes se crean en una máquina virtual Java (JVM) sólo si una aplicación dentro de esa JVM busca el gestor de trabajo. Por ejemplo, si hay 10 agrupaciones de hebras (gestores de trabajo) definidas, no se crea ninguna hasta que una aplicación busca estas agrupaciones.

Importante: Los gestores de trabajo no soportan el envío de trabajo a las JVM remotas.

Gestor de trabajo CommonJ

El gestor de trabajo CommonJ contiene un subconjunto de los métodos de gestor de trabajo de beans asíncronos. Aunque el gestor de trabajo CommonJ funciona en un entorno Java EE, la interfaz no devuelve una instancia nueva para cada búsqueda de denominación JNDI, puesto que esta especificación no está incluida en la especificación Java EE.

La función opcional de especificación de trabajo CommonJ para trabajar de forma remota no recibe soporte. Aunque una unidad de trabajo implemente la interfaz java.io.Serializable, la unidad de trabajo no se ejecuta de forma remota.

Cómo buscar un ejecutor gestionado

Una aplicación puede buscar un ejecutor gestionado de la siguiente manera. En este ejemplo, el componente contiene una referencia de entorno de recursos llamada concurrent/myExecutor, que se ha enlazado con un gestor de trabajo físico cuando se ha desplegado el componente:
InitialContext ic = new InitialContext(); 
ManagedExecutorService executor = (ManagedExecutorService) ic.lookup("java:comp/env/concurrent/myExecutor");

Contextos Java EE de herencia

Las tareas enviadas a los ejecutores gestionados y gestores de trabajo pueden heredar los siguientes contextos de Java EE de la hebra de envío. Los proxy contextuales pueden heredar estos tipos de contextos de la hebra que invoca el servicio de contexto para crear el proxy contextual. Las hebras de la fábrica de hebras gestionadas pueden heredar estos tipos de contextos de la hebra que busca o inyecta la fábrica de hebras gestionadas.
Contexto de internacionalización
Cuando se selecciona esta opción y se habilita el servicio de internacionalización, y el contexto de internacionalización que existe en la hebra de planificación está disponible en la hebra de destino.
Área de trabajo
Cuando se selecciona esta opción, el contexto del área de trabajo de cada partición de área de trabajo que existe en la hebra de planificación está disponible en la hebra de destino.
Perfil de aplicación (en desuso)
El contexto de perfil de aplicación no se soporta y no está disponible para la mayoría de aplicaciones. Para las aplicaciones Java EE 1.3, cuando se selecciona esta opción, se habilita el servicio de perfilado de aplicaciones y se selecciona la propiedad de servicio de perfilado de aplicaciones modalidad de compatibilidad de 5.x. La tarea de perfil de aplicaciones asociada con la hebra de planificación está disponible en la hebra de destino para las aplicaciones Java EE 1.3. Para aplicaciones Java EE 1.4 o superiores, la tarea de perfil de aplicación es una propiedad de la unidad de trabajo asociada, en lugar de una hebra. Esta opción no afecta al comportamiento de la tarea en aplicaciones Java EE 1.4 o superiores. El trabajo planificado que se ejecuta en una aplicación Java EE 1.4 no recibe la tarea de perfilado de la hebra de planificación.
Security
La tarea se puede ejecutar como asíncrona o como el cliente autenticado en la hebra que la ha creado y enviado. Este comportamiento es de gran utilidad porque la tarea sólo puede hacer lo que haga el que la invoca. Esta acción es más útil que un mecanismo RUN_AS, por ejemplo, que impide este tipo de comportamiento. Cuando se selecciona la opción Seguridad, el sujeto JAAS que existe en la hebra de planificación está disponible en la hebra de destino. Si no se selecciona, la hebra se ejecuta de forma anónima.
Metadatos del componente
Los metadatos del componente son sólo relevantes cuando la tarea es un objeto Java simple. Si la tarea es un componente Java EE, por ejemplo, un enterprise bean, los metadatos del componente se activan.

Los contextos que se pueden heredar dependen del gestor de trabajo que utiliza la aplicación que envía la tarea. Con la consola administrativa, el administrador define la política de contexto adhesivo de un gestor de trabajo seleccionando los servidos en los que estará disponible el gestor de trabajo.

Modelo de programación

Los gestores de trabajo dan soporte a los modelos de programación siguientes.
  • Programas de utilidad de simultaneidad para Java EE. La especificación Java EE estandariza este modelo de programación, que incluye ejecutores gestionados y ejecutores planificados gestionados, que heredan de la API java.util.concurrent de Java SE familiar. También incluye el servicio de contexto, que no tiene ningún equivalente en la API java.util.concurrent.
  • Beans asíncronos. Los beans asíncronos actuales Gestor de trabajo, Origen de sucesos, ámbitos asíncronos, supervisores de subsistema e interfaces de contexto de Java EE forman parte de un modelo de programación de beans asíncronos.
  • Especificación CommonJ. El modelo de programación CommonJ utiliza WorkManager y TimerManager para gestionar hebras y temporizadores de forma asíncrona en el entorno de Java EE.

Para obtener más información sobre las API de ejecutores gestionados, fábricas de hebras, servicios de contexto y del gestor de trabajo, consulte el Javadoc.

Ejemplos de simultaneidad

Tabla 1. Búsqueda del ejecutor gestionado o el gestor de trabajo
Ejecutor gestionado Beans asíncronos CommonJ
InitialContext ctx = new InitialContext();
ManagedExecutorService executor =
(ManagedExecutorService)
   ctx.lookup("java:comp/env/wm/myWorkMgr");
InitialContext ctx = new InitialContext();
com.ibm.websphere.asynchbeans.WorkManager wm  =
(com.ibm.websphere.asynchbeans.WorkManager)
           ctx.lookup(“java:comp/env/wm/MyWorkMgr”);
InitialContext ctx = new InitialContext();
commonj.work.WorkManager wm =
 (commonj.work.WorkManager)
           ctx.lookup(“java:comp/env/wm/MyWorkMgr”);
Tabla 2. Crear la tarea
Ejecutor gestionado Beans asíncronos CommonJ
 public class MyWork implements Callable<Integer> {
     public Integer call() {
              System.out.println(“Running.....”);
       		return 1;
     }
   }
public class MyWork implements   
com.ibm.websphere.asynchbeans.Work {
   public void release() {
            ......
   }
   public void run() {
           System.out.println(“Running.....”);
}
public class MyWork implements 
commonj.work.Work{
   	   public boolean isDaemon() {
       return false;
   }
   public void release() {
        .....
   }
    public void run () {
            System.out.println(“Running.....”);
  }
Tabla 3. Enviar la tarea
Ejecutor gestionado Beans asíncronos CommonJ
	MyWork work1 = new MyWork();
	MyWork work2 = new MyWork();

	// caso 1: bloquear hasta que se hayan completado todos los elementos
Collection<MyWork> tasks =
    Arrays.asList(work1, work2);
List<Future<Integer>> futures =
    executor.invokeAll(tasks);
for (Future<Integer> future : futures)
    System.out.println("work data=" + future.get());

//caso 2: esperar hasta 1000 milisegundos a que se complete alguno de los elementos
Integer result = executor.invokeAny(
    tasks, 1, TimeUnit.SECONDS);
System.out.println("work data=" + result);
	MyWork work1 = new MyWork();
	MyWork work2 = new MyWork();

	WorkItem item1;
	WorkItem item2;
	Item1=wm.startWork(work1);
	Item2=wm.startWork(work2);
	
	// caso 1: bloquear hasta que se hayan completado todos los elementos
	ArrayList col1 = new ArrayList();
	Col1.add(item1);
	Col1.add(item2);
wm.join(col1, WorkManager.JOIN_AND, WorkManager.INDEFINITE);
	// una vez completados los trabajos
 System.out.println(“work1 data=”+work1.getData());
 System.out.println(“work2 data=”+work2.getData());
	
	// debe completar el caso 1 antes que el caso 2
//caso 2: esperar hasta 1000 milisegundos a que se complete alguno de los elementos
Boolean ret = wm.join(col1, WorkManager.JOIN_OR, 1000);
	MyWork work1 = new MyWork();
	MyWork work2 = new MyWork();
	
	WorkItem item1;
	WorkItem item2;
	Item1=wm.schedule(work1 );
	Item2=wm.schedule(work2);
	
	// caso 1: bloquear hasta que se hayan completado todos los elementos
	Collection col1 = new ArrayList();
	col1.add(item1);
	col1.add(item2);
	wm.waitForAll(col1, WorkManager.INDEFINITE);
	// una vez completados los trabajos
 System.out.println(“work1 data=”+work1.getData());
 System.out.println(“work2 data=”+work2.getData());
	
	// debe completar el caso 1 antes que el caso 2
//caso 2: esperar hasta 1000 milisegundos a que se complete alguno de los elementos
Collection finished = wm.waitForAny(col1,1000);
	// comprobar el estado de workItems
if (finished != null) {
	  Iterator I = finished.iterator();
	  	  if (i.hasNext()) {
	     	     WorkItem wi = (WorkItem) i.next();
	      	      if (wi.equals(item1)) {
	                 System.out.println(“work1 =
 					 				 “+ work1.getData());
	      	      } else if (wi.equals(item2)) {
	                 System.out.println(“work1 =
					  				 “+ work1.getData());
	      }
	  }
}
Tabla 4. Crear un ejecutor planificado gestionado, un gestor de alarmas o un gestor de temporizador
Ejecutor planificado gestionado Beans asíncronos CommonJ
InitialContext ctx = new InitialContext();
ManagedScheduledExecutorService executor =
  (ManagedScheduledExecutorService)
    ctx.lookup("java:comp/env/wm/MyWorkMgr");
InitialContext ctx = new InitialContext();
com.ibm.websphere.asynchbeans.WorkManager wm  =
    (com.ibm.websphere.asynchbeans.WorkManager)
              ctx.lookup(“java:comp/env/wm/MyWorkMgr”);	
	AsynchScope ascope;
Try {
     Ascope = wm.createAsynchScope(“ABScope”);
	} Catch (DuplicateKeyException ex)
{
       Ascope = wm.findAsynchScope(“ABScope”);
   ex.printStackTrace();
}

	// obtener un AlarmManager 
	AlarmManager  aMgr= ascope.getAlarmManager();
InitialContext ctx = new InitialContext();
	Commonj.timers.TimerManager tm =
 (commonj.timers.TimerManager)
   ctx.lookup(“java:comp/env/tm/MyTimerManager”);
Tabla 5. Planificar una tarea, alarma o temporizador
Ejecutor planificado gestionado Beans asíncronos CommonJ
// create task
Runnable task = new StockQuoteTask(
    “qqq”, “johndoe@example.com”);
ScheduledFuture<?> future =
     executor.schedule(task, 1, TimeUnit.MINUTES);

// Retardo fijo: planificar tarea a ejecutar
// en 1 minuto a partir de ahora y repetir cada
	// hora a continuación.
ScheduledFuture<?> future =
    executor.scheduleWithFixedDelay(
        task, 1, 60, TimeUnit.MINUTES);

// Proporción fija: planificar temporizador para que caduque
// en 1 minuto a partir de ahora y repetir cada
	// hora a continuación
ScheduledFuture<?> future =
    executor.scheduleAtFixedRate(
        task, 1, 60, TimeUnit.MINUTES);
// create alarm
	ABAlarmListener listener = new ABAlarmListener();
	Alarm am = 
   aMgr.create(listener, “SomeContext”, 1000*60);
// create timer
	TimerListener listener =
 new StockQuoteTimerListener(“qqq”,
 “johndoe@example.com”);
	Timer timer = tm.schedule(listener, 1000*60);
	
	// Retardo fijo: programar temporizador para que caduque
	// a los 60 segundos a partir de entonces y repetir cada hora
	// en lo sucesivo.
Timer timer = tm.schedule(listener, 1000*60, 1000*30);
	
	// Retardo fijo: programar temporizador para que caduque
	// a los 60 segundos a partir de entonces y repetir cada hora
// a continuación
Timer timer = tm.scheduleAtFixedRate(listener, 1000*60, 1000*30);

Icon that indicates the type of topic Concept topic



Timestamp icon Last updated: last_date
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=casb_workmgr
File name: casb_workmgr.html