Gerenciadores de Trabalho

Um gerenciador de trabalho fornece passagem para Java™ Platform, aplicativos Enterprise Edition (Java EE).

Utilizando o console administrativo, um administrador pode configurar um número indefinido de gerenciadores de trabalho. O administrador especifica as propriedades do gerenciador de trabalho, incluindo a política de herança de contexto Java EE para tarefas enviadas ao gerenciador de trabalho. O administrador liga cada gerenciador de trabalho a um local exclusivo em JNDI (Java Naming and Directory Interface). É possível utilizar objetos do gerenciador de trabalho em qualquer uma das seguintes interfaces:
  • Executores gerenciados
    • javax.enterprise.concurrent.ManagedExecutorService
    • javax.enterprise.concurrent.ManagedScheduledExecutorService
    • java.util.concurrent.ExecutorService
    • java.util.concurrent.ScheduledExecutorService
  • Factories de encadeamento
    • javax.enterprise.concurrent.ManagedThreadFactory
    • java.util.concurrent.ThreadFactory
  • Serviço de contexto de encadeamento
    • javax.enterprise.concurrent.ContextService
  • Beans assíncronos
    • com.ibm.websphere.asynchbeans.WorkManager
  • Gerenciador de trabalho CommonJ
    • commonj.work.WorkManager
O tipo de interface selecionado é resolvido durante o tempo de consulta do JNDI com base no valor que você especificar na referência do ambiente de recursos.

Os gerenciadores fornecem um modelo de programação para os aplicativos Java EE. Para obter mais informações, consulte a seção Modelo de programação.

Evitar Problemas Evitar Problemas: A classe javax.resource.spi.work.WorkManager é uma interface Java para ser usada pelos adaptadores de recursos Java EE Connector Architecture (JCA). Ela não é uma implementação real do WorkManager, que é usado por by Java EE.gotcha

Quando você estiver gravando um componente da Web ou do Enterprise JavaBeans (EJB) que usa Utilitários de simultaneidade para Java EE ou beans assíncronos, o desenvolvedor deverá incluir uma referência do ambiente de recursos em cada componente que precisar de acesso a um executor gerenciado, factory de encadeamento, serviço de contexto, ou gerenciador de trabalho. Para obter mais informações sobre as referências de recurso, consulte o tópico Referência. O componente procura um executor gerenciado, factory de encadeamento, serviço de contexto ou gerenciador de trabalho que usa um nome lógico no componente, java: comp namespace, exatamente como ele procura uma origem de dados, enterprise bean ou connection factory.

O implementador liga os gerenciadores de trabalho físico a referências de ambiente de recursos lógicos (executores gerenciados, factory de encadeamento, serviços de contexto ou gerenciadores de trabalho) quando o aplicativo é implementado.

Por exemplo, se um desenvolvedor precisar de três conjuntos de encadeamentos para dividir o trabalho entre os níveis bronze, prata e ouro, o desenvolvedor escreverá o componente para coletar um conjunto lógico baseado em um atributo no perfil do aplicativo cliente. O implementador tem a flexibilidade de decidir como mapear esse pedido para três conjuntos de encadeamento. O implementador pode decidir usar um único conjunto de encadeamentos em um pequeno sistema. Nesse caso, o implementador liga todas as três referências de recursos à mesma instância do gerenciador de trabalho (ou seja, ao mesmo nome JNDI). Um sistema maior pode suportar três conjuntos de encadeamentos, portanto, o implementador liga cada referência de recurso a um gerenciador de trabalho diferente. Os gerenciadores de trabalho podem ser compartilhados entre vários aplicativos Java EE instalados no mesmo servidor.

Um desenvolvedor de aplicativos pode usar tantas referências de ambientes de recursos lógicos quantas forem necessárias. O implementador escolhe se deseja mapear um gerenciador de trabalho físico ou vários para o executor gerenciado lógico, factory de encadeamento, serviço de contexto ou gerenciador de trabalho definido no aplicativo.

Todos os componentes Java EE que precisam compartilhar objetos de escopo assíncrono devem utilizar o mesmo gerenciador de trabalho. Estes objetos de escopo possuem uma afinidade com um único gerenciador de trabalho. Um aplicativo que usa escopos assíncronos deve verificar se todos os componentes que usam objetos de escopo também usam o mesmo gerenciador de trabalho.

Quando vários gerenciadores de trabalho são definidos, os conjuntos de encadeamento subjacentes são criados em uma JVM (Java Virtual Machine) apenas se um aplicativo dentro dessa JVM consulta o gerenciador de trabalho. Por exemplo, com 10 conjuntos de encadeamentos (gerenciadores de trabalho) definidos, nenhum será criado até que um aplicativo consulte esses conjuntos.

Importante: Os gerenciadores de trabalho não suportam o envio de trabalho para JVMs remotas.

Gerenciador de Trabalho CommonJ

O gerenciador de trabalho CommonJ contém um subconjunto dos métodos do gerenciador de trabalho de beans assíncronos. Embora o gerenciador de trabalho CommonJ funcione em um ambiente Java EE, a interface não retorna uma nova instância para cada consulta de nome JNDI, uma vez que esta especificação não está incluída na especificação Java EE.

O recurso opcional de especificação de Trabalho CommonJ para trabalhar executando remotamente não é suportado. Mesmo que uma unidade de trabalho implemente a interface java.io.Serializable, a unidade de trabalho não é executada remotamente.

Como consultar um executor gerenciado

Um aplicativo pode consultar um executor gerenciado como a seguir. Aqui, o componente contém uma referência do ambiente de recurso chamada concurrent/myExecutor, a qual foi ligada a um gerenciador de trabalho físico quando o componente foi implementado:
InitialContext ic = new InitialContext();
ManagedExecutorService executor = (ManagedExecutorService) ic.lookup("java:comp/env/concurrent/myExecutor");

Contextos de Java EE da Herança

As tarefas que forem enviadas para executores gerenciados e gerenciadores de trabalho podem herdar o contextos Java EE a seguir do encadeamento de envio. Os proxies contextuais podem herdar esses tipos de contextos a partir do encadeamento que chama o serviço de contexto para criar o proxy contextual. Os encadeamentos do thread factory gerenciado podem herdar esses tipos de contextos a partir do encadeamento que consulta ou injeta o thread factory gerenciado.
Contexto de Internacionalização
Quando esta opção é selecionada e o serviço de internacionalização é ativado, e o contexto de internacionalização existente no encadeamento de planejamento fica disponível no encadeamento de destino.
Área de Trabalho
Quando esta opção é selecionada, o contexto da área de trabalho para cada partição da área de trabalho existente no encadeamento de planejamento fica disponível no encadeamento de destino.
Perfil do Aplicativo (reprovado)
O contexto de perfil do aplicativo não é suportado e não está disponível para a maioria dos aplicativos. Para aplicativos Java EE 1.3, quando esta opção está selecionada, o serviço do perfil do aplicativo é ativado e a propriedade de serviço do perfil do aplicativo, modo de compatibilidade 5.x, é selecionada. A tarefa do perfil do aplicativo que está associada ao encadeamento de planejamento está disponível no encadeamento de destino para aplicativos Java EE 1.3. Para aplicativos Java EE 1.4 ou posterior, a tarefa de perfil do aplicativo é uma propriedade de sua unidade de trabalho associada, em vez de um encadeamento. Essa opção não tem efeito sobre o comportamento da tarefa em aplicativos Java EE 1.4 ou posterior. O trabalho planejado que é executado em um aplicativo Java EE 1.4 não recebe a tarefa de definição de perfil do encadeamento de planejamento.
Segurança
A tarefa pode ser executada como anônima ou como o cliente autenticado no encadeamento que a criou. Esse comportamento é útil porque a tarefa pode executar somente o que o responsável pela chamada pode fazer. Essa ação é mais útil do que um mecanismo RUN_AS, por exemplo, que impede esse tipo de comportamento. Quando você seleciona a opção Segurança, o objeto JAAS existente no encadeamento de planejamento fica disponível no encadeamento de destino. Se não for selecionada, o encadeamento é executado anonimamente.
Metadados de Componente
O metadados do componente é relevante somente quando a tarefa é um objeto Java simples. Se a tarefa for um componente Java EE, como um enterprise bean, o metadados do componente está ativo.

Os contextos que podem ser herdados dependem do gerenciador de trabalho, o qual é usado pelo aplicativo que cria e envia a tarefa. Utilizando o administrative console, o administrador define o critério de contexto de sticky de um gerenciador de trabalho, selecionando os serviços nos quais o gerenciador de trabalho deve ser disponibilizado.

Modelo de programação

Os gerenciadores de trabalho suportam os seguintes modelos de programação.
  • Utilitários de simultaneidade para Java EE. A especificação do Java EE padroniza esse modelo de programação, o qual inclui Executores gerenciados, Executores planejados gerenciados e Thread factory gerenciado, que é herdado da API Java SE java.util.concurrent familiar. Ele também inclui o Serviço de contexto, que não possui equivalente na API java.util.concurrent.
  • Beans assíncronos. Os beans assíncronos atuais como Gerenciador de trabalho, Origem de eventos, escopos assíncronos, monitores de subsistema e interfaces de Contexto Java EE fazem parte do modelo de programação de beans assíncronos.
  • Especificação CommonJ. O modelo de programação CommonJ usa o WorkManager e o TimerManager para gerenciar encadeamentos e cronômetros de modo assíncrono no ambiente Java EE.

Para obter mais informações sobre as APIs executores gerenciados, factories de encadeamento, serviço de contexto e gerenciador de trabalho, consulte o Javadoc.

Exemplos de simultaneidade

Tabela 1. Consulte o executor gerenciado ou o gerenciador de trabalho
Executor Gerenciado Beans assí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");
Tabela 2. Crie sua tarefa
Executor Gerenciado Beans assí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.....");
  }
Tabela 3. Envie a tarefa
Executor Gerenciado Beans assíncronos CommonJ
MyWork work1 = new MyWork();
MyWork work2 = new MyWork();

// caso 1: bloquear até a conclusão de todos os itens
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: aguarde até 1000 milissegundos para a conclusão de todos os itens.
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 até a conclusão de todos os itens
ArrayList col1 = new ArrayList();
Col1.add(item1);
Col1.add(item2);
wm.join(col1, WorkManager.JOIN_AND, WorkManager.INDEFINITE);
// quando os trabalhos estiverem concluídos
System.out.println("work1 data="+work1.getData());
System.out.println("work2 data="+work2.getData());
	
// você deve concluir o caso 1 antes do caso 2
//caso 2: aguarde até 1000 milissegundos para a conclusão de todos os itens.
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 até a conclusão de todos os itens
Collection col1 = new ArrayList();
col1.add(item1);
col1.add(item2);
wm.waitForAll(col1, WorkManager.INDEFINITE);
// quando os trabalhos estiverem concluídos
System.out.println("work1 data="+work1.getData());
System.out.println("work2 data="+work2.getData());
	
// você deve concluir o caso 1 antes do caso 2
//caso 2: aguarde até 1000 milissegundos para a conclusão de todos os itens.
Collection finished = wm.waitForAny(col1,1000);
// verificar status 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());
	      }
	  }
}
Tabela 4. Crie um executor planejado gerenciado, gerenciador de alarme ou gerenciador do cronômetro
Executor Planejado Gerenciado Beans assí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();
}

// obter um AlarmManager 
AlarmManager  aMgr= ascope.getAlarmManager();
InitialContext ctx = new InitialContext();
Commonj.timers.TimerManager tm =
 (commonj.timers.TimerManager)
   ctx.lookup(“java:comp/env/tm/MyTimerManager”);
Tabela 5. Planeje uma tarefa, alarme ou cronômetro.
Executor Planejado Gerenciado Beans assíncronos CommonJ
// create task
Runnable task = new StockQuoteTask(
    “qqq”, “johndoe@example.com”);
ScheduledFuture<?> future =
     executor.schedule(task, 1, TimeUnit.MINUTES);

// Fixed-delay: schedule task to run
// 1 minute from now and repeat every
// hora depois disso.
ScheduledFuture<?> future =
    executor.scheduleWithFixedDelay(
        task, 1, 60, TimeUnit.MINUTES);

// Fixed-rate: schedule timer to expire
// 1 minute from now and repeat every
// hora após
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 fixo: planejar cronômetro para expirar em
// 60 segundos a partir de agora e repetir a cada
// hora depois disso.  
Timer timer = tm.schedule(listener, 1000*60, 1000*30);
	
// Taxa fixa: planejar cronômetro para expirar em
// 60 segundos a partir de agora e repetir a cada
// hora após
Timer timer = tm.scheduleAtFixedRate(listener, 1000*60, 1000*30);

Ícone que indica o tipo de tópico Tópico de Conceito



Ícone de registro de data e hora Última atualização: last_date
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=casb_workmgr
Nome do arquivo: casb_workmgr.html