J2EE: Concorrência na Plataforma Java EE 7

A especifica��o da API para utilit�rios concorrentes para a plataforma Java EE 7 est� definida na JSR 236 que pode ser baixada no site oficial da Oracle.

Esse recurso de concorr�ncia que � disponibilizado na plataforma Java EE fornece uma API simples e padronizada para utiliza��o de concorr�ncia pelos componentes da aplica��o sem comprometer a integridade do container e ainda mant�m os benef�cios fundamentais da plataforma Java EE.

Os containers Java EE como os EJBs ou containers Web n�o permitem diretamente a utiliza��o das APIs de concorr�ncia do Java SE tais como java.util.concurrent.ThreadPoolExecutor, java.lang.Thread, ou java.util.Timer.

Isto ocorre, pois todo o c�digo da aplica��o est� sendo executado em uma thread gerenciada pelo container, e cada container normalmente espera que todos os acessos a objetos fornecidos pelo container ocorram na mesma thread. Isso permite que o container gerencie os recursos e forne�a uma administra��o centralizada. Al�m disso, a utiliza��o de recursos de forma n�o gerenciada n�o � encorajada, pois pode prejudicar diversos recursos que a plataforma � projetada a fornecer, tais como disponibilidade, seguran�a, confiabilidade e escalabilidade.

Esta API disponibilizada na plataforma Java EE 7 estende a API Concurrency Utilities que foi desenvolvido sob a especifica��o JSR-166y e que tamb�m � encontrada na Java 2 Platform, Standard Edition 7 (Java SE 7) no pacote java.util.concurrent. A boa not�cia � que desenvolvedores de aplica��es que j� est�o familiarizados com essa API poder�o utilizar as suas bibliotecas existentes e tamb�m usar padr�es que j� eram utilizados efetuando poucas modifica��es. Assim, isso permitir� que possamos adicionar princ�pios de concorr�ncia para as aplica��es Java EE existentes usando padr�es de projeto existentes.

Veremos no restante do artigo mais fun��es disponibilizadas pela API de concorr�ncia da plataforma Java EE 7.

Tarefas Ass�ncronas

A classe ManagedExecutorService presente no pacote javax.enterprise.concurrent � uma vers�o gerenciada da classe ExecutorService do pacote java.util.concurrent. Esta classe ManagedExecutorService fornece m�todos para que possamos submeter tarefas ass�ncronas no ambiente Java EE.

Podemos obter uma inst�ncia de ManagedExecutorService utilizando a pesquisa JNDI. Um ManagedExecutorService padr�o est� dispon�vel com o JNDI "java:comp/DefaultManagedExecutorService".

Segue na Listagem 1 um exemplo de como poder�amos obter um ManagedExecutorService.

Listagem 1. Obtendo um ManagedExecutorService utilizando uma pesquisa JNDI.


  InitialContext ctx = new InitialContext();
  ManagedExecutorService executor =
  (ManagedExecutorService)ctx.lookup("java:comp/DefaultManagedExecutorService");

Tamb�m podemos injetar um ManagedExecutorService na aplica��o usando a anota��o @Resource. Segue na Listagem 2 um exemplo de como poder�amos obter um ManagedExecutorService utilizando a anota��o @Resource:

Listagem 2. Obtendo um ManagedExecutorService utilizando anota��es.


  @Resource(lookup="java:comp/DefaultManagedExecutorService")
  ManagedExecutorService executor;

Podemos obter um ManagedExecutorService espec�fico para uma aplica��o adicionando o seguinte fragmento de c�digo no arquivo web.xml, presente na Listagem 3.

Listagem 3. Obtendo um ManagedExecutorService espec�fico para aplica��o.


  <resource-env-ref>
                  <resource-env-ref-name>
                                 concurrent/meuExecutor
                  </resource-env-ref-name>
   
                  <resource-env-ref-type>
                                 javax.enterprise.concurrent.ManagedExecutorService
                  </resource-env-ref-type>
  </resource-env-ref>

Neste c�digo, o elemento define o nome do JNDI relativo ao recurso "java:comp/env", sendo recomend�vel que tenhamos a refer�ncia do ambiente JNDI no subcontexto de "java:comp/env/concurrent". O elemento define o tipo de refer�ncia do ambiente de recursos JNDI. ManagedScheduledExecutor pode ent�o ser obtido com a refer�ncia JNDI ou @Resource, mas com o nome "concurrent/meuExecutor".

A unidade de trabalho que precisa ser executada concorrentemente � chamada de tarefa (ou task). Uma tarefa � uma implementa��o concreta da interface java.lang.Runnable conforme mostra o exemplo da Listagem 4.

Listagem 4. Criando uma tarefa atrav�s da implementa��o da interface Runnable.


  public class MinhaTarefa1 implements Runnable {
                  @Override
                  public void run() {
                                 //C�digo a ser executado aqui
                  }
  }

Uma tarefa tamb�m pode ser definida como uma implementa��o concreta da interface java.util.concurrent.Callable conforme mostra o exemplo da Listagem 5.

Listagem 5. Criando uma tarefa atrav�s da implementa��o da interface Callable.


  public class MinhaTarefa2 implements Callable<Product> {
                  private int id;
   
                  public MinhaTarefa2(int id) {
                                 this.id = id;
                  }
   
                  @Override
                  public Produto call() {
                                 Produto produto = new Produto(id);
                                 //Mais c�digo aqui
                                 return produto;
                  }
  }

Neste c�digo, Produto � uma classe espec�fica da aplica��o. O atributo id fornece um identificador para a tarefa e � usado para inicializar o Produto. O m�todo call � chamado para computar o resultado da tarefa ou ent�o lan�ar uma exce��o caso ocorra algum problema.

Existem basicamente duas diferen�as entre uma tarefa que implementa Callable e outra que implementa Runnable. Uma tarefa Callable pode retornam um resultado, enquanto que uma tarefa Runnable n�o pode. A segunda diferen�a � que uma tarefa Callable pode lan�ar uma exce��o checada, enquanto que Runnable n�o pode.

Os beans CDI podem ser submetidos como tarefas, mas � recomendado que eles n�o estejam nos escopos @RequestScoped, @SessionScoped, ou @ConversationScoped. No entanto, os beans CDI com escopo @Application ou @Dependent podem ser usados como tarefas.

Podemos submeter instancias de uma tarefa para um ManagedExecutorService usando os m�todos submit, execute, invokeAll, ou invokeAny.

O m�todo submit submete uma tarefa Runnable ou Callable e retorna um Future representando a tarefa. Segue um exemplo na Listagem 6.

Listagem 6. Submetendo uma tarefa e recebendo um Future como retorno.


  Future future = executor.submit(new MinhaTarefa1());

Outro m�todo que pode ser utilizado � o m�todo execute. O m�todo execute executa uma tarefa Runnable em algum momento no futuro. Segue na Listagem 7 um exemplo.

Listagem 7. Utilizando o m�todo execute para submeter a tarefa.

executor.execute(new MinhaTarefa1());

J� o m�todo invokeAll executa todas as tarefas submetidas em uma Collection e retorna uma List> com os status e resultados quando completadas. Segue na Listagem 8 um exemplo.

Listagem 8. Executando todas as tarefas submetidas na Collection utilizando invokeAll.


  Collection<Callable<Produto>> tarefas = new ArrayList<>();
  tarefas.add(new MinhaTarefa2(1));
  tarefas.add(new MinhaTarefa2(2));
  //Mais c�digo aqui
  List<Future<Produto>> resultados = executor.invokeAll(tarefas);
  Produto resultado = resultados.get(0).get();

Neste c�digo, uma Collection de Callable � criada e submetida atrav�s do m�todo invokeAll. O resultado � retornado como List> e o primeiro resultado � acessado. O m�todo invokeAll tem outra varia��o em que podemos especificar o timeout.

O m�todo invokeAny executa qualquer tarefa submetida na Collection e retorna o resultado de um que tenha completado com sucesso, sem lan�ar uma exce��o. Segue na Listagem 9 um exemplo.

Listagem 9. Executando qualquer uma das tarefas submetidas na Collection utilizando invokeAny.


  Collection<Callable<Produto>> tarefas = new ArrayList<>();
  tarefas.add(new MinhaTarefa2(1));
  tarefas.add(new MinhaTarefa2 (2));
  //Mais c�digo aqui
  Produto resultado = executor.invokeAny(tarefas);

Neste c�digo, uma Collection de Callable � criada e submetida atrav�s de invokeAny. O resultado de uma tarefa que tenha sido completada com sucesso � retornado. O m�todo invokeAny tem outra varia��o que � a possibilidade de especificarmos um timeout.

Transa��es inseridas nas tarefas tamb�m podem ser explicitamente iniciadas, confirmadas (commit) ou revertidas (roll back) atrav�s da classe javax.transaction.UserTransaction conforme mostra o exemplo da Listagem 10.

Listagem 10. Utilizando transa��es nas tarefas.


  public class MinhaTarefa implements Runnable {
                  @Override
                  public void run() {
                                 InitialContext context = new InitialContext();
                                 TransacaoUsuario tx = (TransacaoUsuario)context.lookup("java:comp/ TransacaoUsuario ");
                                 tx.start();
                                 //. . .
                                 tx.commit();
                  }
  }

Cada tarefa tamb�m pode implementar a interface ManagedTask para fornecer informa��es de identifica��o da tarefa, receber notifica��o dos eventos do ciclo de vida da tarefa, ou fornecer propriedades de execu��o adicionais.

Uma tarefa pode implementar tamb�m a interface ManagedTaskListener para receber notifica��es de eventos do ciclo de vida. Esta interface fornece os m�todos taskSubmitted, taskStarting, taskDone e taskAborted. O m�todo taskSubmitted � chamado ap�s a tarefa ser submetida para o Executor. O m�todo taskStarting � chamado antes que a tarefa est� prestes a come�ar. O m�todo taskDone � chamado quando uma tarefa submetida completou a execu��o com sucesso ou n�o. O m�todo taskAborted � chamado quando uma tarefa foi cancelada.

Segue na Listagem 11 um exemplo de uma tarefa que implementa esses m�todos.

Listagem 11. Implementando m�todos para receber eventos do ciclo de vida.


  public class MinhaTarefa implements Runnable, ManagedTask, ManagedTaskListener {
                  @Override
                  public void run() {
                                 //Mais c�digo aqui�
                  }
   
                  @Override
                  public void taskSubmitted(Future<?> f, ManagedExecutorService m, Object o) {
                                 //Mais c�digo aqui�
                  }
   
                  @Override
                  public void taskStarting(Future<?> f, ManagedExecutorService m, Object o) {
                                 //Mais c�digo aqui�
                  }
   
                  @Override
                  public void taskAborted(Future<?> f, ManagedExecutorService m, Object o, Throwable t) {
                                 //Mais c�digo aqui�
                  }
   
                  @Override
                  public void taskDone(Future<?> f, ManagedExecutorService m, Object o, Throwable t) {
                                 //Mais c�digo aqui�
                  }
   
  }

Agendamento de Tarefas

A classe ManagedScheduledExecutorService do pacote javax.enterprise.concurrent fornece uma vers�o gerenciada do ScheduledExecutorService e pode ser usado para agendar tarefas em hor�rios espec�ficos e peri�dicos.

Podemos obter uma inst�ncia de ManagedScheduledExecutorService atrav�s de uma pesquisa JNDI usando as refer�ncias do ambiente JNDI. Um ManagedScheduledExecutorService padr�o est� dispon�vel sob o nome JNDI �java:comp/DefaultManagedScheduledExecutorService�.

Podemos ent�o obter o ManagedScheduledExecutorService conforme mostra o exemplo da Listagem 12.

Listagem 12. Obtendo ManagedScheduledExecutorService utilizando a pesquisa JNDI.


  InitialContext ctx = new InitialContext();
  ManagedScheduledExecutorService executor = (ManagedScheduledExecutorService)ctx.lookup("java:comp/DefaultManagedScheduledExecutorService");

Podemos tamb�m injetar ManagedScheduledExecutorService na aplica��o conforme mostra o exemplo da Listagem 13.

Listagem 13. Injetando ManagedScheduledExecutorService na aplica��o.


  @Resource:
  @Resource(lookup="java:comp/DefaultManagedScheduledExecutorService")
  ManagedScheduledExecutorService executor;

Podemos obter um ManagedScheduledExecutorService espec�fico para aplica��o adicionando o seguinte fragmento de c�digo no web.xml conforme mostra o exemplo da Listagem 14.

Listagem 14. Definindo um ManagedScheduledExecutorService espec�fico de aplica��o.


  <resource-env-ref>
                  <resource-env-ref-name>
                                 concurrent/meuScheduledExecutor
                  </resource-env-ref-name>
   
                  <resource-env-ref-type>
                                 javax.enterprise.concurrent.ManagedScheduledExecutorService
                  </resource-env-ref-type>
  </resource-env-ref>

Neste c�digo, o elemento define o nome JNDI do recurso relativo a �java:comp/env�. Tamb�m recomenda-se que as refer�ncias do ambiente JNDI estejam no subcontexto �java:comp/env/concurrent�. O elemento define o tipo da refer�ncia do ambiente JNDI. O ManagedScheduledExecutorService pode ent�o ser obtido com a refer�ncia JNDI e @Resource, mas com o nome concurrent/meuScheduledExecutor.

Assim como no ManagedExectorService, uma tarefa � uma implementa��o concreta da interface java.lang.Runnable ou java.util.concurrent.Callable.

Submetemos inst�ncias de tarefas para ManagedScheduledExecutorService usando qualquer um dos m�todos submit, execute, invokeAll, invokeAny, schedule, scheduleAtFixedRate, ou scheduleWithFixedDelay.

Os m�todos submit, execute, invokeAll, e invokeAny se comportam como no ManagedExecutorService. Os outros m�todos s�o explicados abaixo:

O m�todo schedule possui a assinatura " ScheduledFuture schedule(Callable callable, Trigger trigger)". Este m�todo cria e executa uma tarefa baseada em um Trigger.
O m�todo schedule com a seguinte assinatura "ScheduledFuture schedule(Runnable command, Trigger trigger)" tamb�m cria e executa uma tarefa baseada em um Trigger, por�m recebe uma tarefa que implementa um Runnable.
O m�todo schedule com a assinatura " ScheduledFuture schedule(Callable callable, long delay, TimeUnit unit)" cria e executa um ScheduledFuture que � ativado ap�s o prazo concedido.
Exemplificando o m�todo schedule criaremos primeiramente uma tarefa usando Callable, conforme mostra o exemplo da Listagem 15.
Listagem 15. Criando uma tarefa implementando um Callable.
```
public class MinhaTarefa implements Callable<Produto> {
                @Override
                public Produto call() {
                               Produto produto = ...;
                               //Mais c�digo aqui
                               return produto;
                }
}
```
Produto � uma classe espec�fica da aplica��o. Agora esta tarefa pode ser agendada conforme a Listagem 16.
Listagem 16. Agendando a tarefa criada acima.
```
ScheduledFuture<Produto> future = executor.schedule(new MinhaTarefa(), 5, TimeUnit.SECONDS);
```
Este c�digo agendar� a tarefa ap�s cinco segundos. O ScheduledFuture retornado pode ser usado para checar o status da tarefa, cancelar a execu��o e retornar o resultado.
O m�todo schedule com a assinatura "ScheduledFuture schedule(Runnable command, long delay, TimeUnit unit)" cria e executa uma a��o de disparo que torna-se ativa ap�s um determinado tempo. Uma tarefa usando Runnable pode ser definida conforme a Listagem 17.
Listagem 17. Criando uma tarefa implementando um Runnable.
```
public class MinhaTarefa implements Runnable {
                @Override
                public void run() {
                               //Mais c�digo aqui
                }
}
```
Agora esta tarefa pode ser agendada conforme mostra a Listagem 18.
Listagem 18. Agendando a tarefa criada acima.
```
ScheduledFuture<?> f = executor.schedule(new MinhaTarefa(), 5, TimeUnit.SECONDS);
```
Este c�digo agendar� a tarefa ap�s 5 segundos. O ScheduledFuture retornado pode ser usado para checar o status da tarefa, cancelar a execu��o e retornar o resultado.
O m�todo scheduleAtFixedRate com a assinatura "ScheduledFuture scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)" cria e executa uma a��o peri�dica que � ativado pela primeira vez ap�s o atraso inicial dado, e, posteriormente, com o per�odo determinado. As execu��es ter�o in�cio ap�s initialDelay, depois initialDelay + period, depois initialDelay + 2 * period, e assim por diante. Segue um exemplo na Listagem 19.
Listagem 19. Exemplo utilizando o m�todo scheduleAtFixedRate.
```
ScheduledFuture<?> scheduleAtFixedRate = executor.scheduleAtFixedRate(new MeuRunnableTask(5), 2, 3, TimeUnit.SECONDS);
```
Este c�digo agendar� a tarefa depois de um atraso inicial de dois segundos e depois a cada tr�s segundos.
Se qualquer execu��o da tarefa encontrar uma exce��o, execu��es subsequentes ser�o canceladas. No entanto, a tarefa terminar� apenas atrav�s de cancelamento ou termina��o do executor.
O ScheduledFuture retornado pode ser usado para checar o status da tarefa, cancelar a execu��o e retornar o resultado.
O m�todo scheduleWithFixedDelay com a assinatura "ScheduledFuture scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)" cria e executa uma a��o peri�dica que � ativada pela primeira vez ap�s o atraso inicial dado, e, posteriormente, com o per�odo determinado entre a termina��o de uma execu��o e o in�cio da pr�xima. Segue na Listagem 20 um exemplo.
Listagem 20. Exemplo utilizando o m�todo scheduleWithFixedDelay.
```
ScheduledFuture<?> scheduleWithFixedDelay = executor.scheduleWithFixedDelay(new MeuRunnableTask(5), 2, 3, TimeUnit.SECONDS);
```
Este c�digo ir� agendar a tarefa depois de um atraso inicial de dois segundos e depois a cada tr�s segundos ap�s isso.
Uma nova tarefa � iniciada apenas ap�s a tarefa anterior ter sido finalizada com sucesso.
Se qualquer execu��o da tarefa encontrar uma exce��o, execu��es subsequentes s�o canceladas. No entanto, a tarefa ser� finalizada apenas atrav�s de cancelamento ou termina��o do executor.
Cada tarefa pode implementar as interfaces ManagedTask e ManagedTaskListener para fornecer informa��es de identifica��o sobre a tarefa, receber notifica��es de eventos do ciclo de Vida da tarefa, ou fornecer propriedades de execu��o adicionais. Este comportamento � semelhante ao ManagedExecutorService.

Threads Gerenciadas

A classe ManagedThreadFactory do pacote javax.enterprise.concurrent pode ser usada para criar threads gerenciadas para execu��o em um ambiente Java EE.

Podemos obter uma inst�ncia de ManagedThreadFactory com o JNDI usando refer�ncias do ambiente JNDI. Um ManagedThreadFactory padr�o est� dispon�vel sob o JNDI de nome java:comp/DefaultManagedThreadFactory.

Podemos ent�o obter um ManagedThreadFactory conforme mostra o exemplo da Listagem 21.

Listagem 21. Obtendo um ManagedThreadFactory padr�o utilizando JNDI.


  InitialContext ctx = new InitialContext();
  ManagedThreadFactory factory = (ManagedThreadFactory)ctx.lookup("java:comp/DefaultManagedThreadFactory");

Podemos injetar ManagedThreadFactory na aplica��o usando @Resource. Segue na Listagem 22 um exemplo.

Listagem 22. Utilizando ManagedThreadFactory na aplica��o usando @Resource.


  @Resource(lookup="java:comp/DefaultManagedThreadFactory")
  ManagedThreadFactory factory;

Podemos obter um ManagedThreadFactory espec�fico de aplica��o adicionando o seguinte fragmento de c�digo no arquivo web.xml, presente na Listagem 23.

Listagem 23. Definindo um ManagedThreadFactory espec�fico para aplica��o.


  <resource-env-ref>
                  <resource-env-ref-name>
                                 concurrent/meuFactory
                  </resource-env-ref-name>
   
                  <resource-env-ref-type>
                                 javax.enterprise.concurrent.ManagedThreadFactory
                  </resource-env-ref-type>
  </resource-env-ref>

Neste c�digo, o elemento define o nome JNDI para o recurso java:comp/env. Tamb�m se recomenda que as refer�ncias do ambiente JNDI estejam no subcontexto java:comp/env/concurrent. O elemento define o tipo de refer�ncia do ambiente JNDI. O ManagedThreadFactory pode ent�o ser obtido com a refer�ncia JNDI e @Resource, mas com o nome de pesquisa concurrent/meuFactory.

Podemos criar novas threads a partir desta factory usando newThread(Runnable r). Segue na Listagem 24 um exemplo.

Listagem 24. Criando uma tarefa.


  public class MinhaTarefa implements Runnable {
                  @Override
                  public void run() {
                                 //Mais c�digo aqui...
                  }
  }

Uma nova thread pode ser criada e iniciada conforme a Listagem 25.

Listagem 25. Criando uma nova thread e iniciando.


  Thread thread = factory.newThread(new MinhaTarefa ());
  thread.start();

As threads retornadas implementam a interface ManageableThread.

Bibliografia

[1] G. Arun, Java EE 7 Essentials. O�Reilly, 2013.

[2] Java Concurrency Utilities. Dispon�vel em https://docs.oracle.com/javase/7/docs/technotes/guides/concurrency/

Tecnologias:

Confira outros conte�dos:

Introdu��o ao JDBC

Novidades do Java

Teste unit�rio com JUnit

Assista grátis a nossa aula inaugural

Perguntas frequentes

Quem somos?

Por que a programação se tornou a profissão mais promissora da atualidade?

Como faço para começar a estudar?

Em quanto tempo de estudo vou me tornar um programador?

Sim, você pode se tornar um programador e não precisa ter diploma de curso superior!

O que eu irei aprender estudando pela DevMedia?

Principais diferenciais da DevMedia

Qual o investimento financeiro que preciso fazer para me tornar um programador?

Como funciona a forma de pagamento da DevMedia?

Por Higor Em 2014

Nossos casos de sucesso

Leonardo Carlos

Eu sabia pouqu�ssimas coisas de programa��o antes de come�ar a estudar com voc�s, fui me especializando em v�rias �reas e ferramentas que tinham na plataforma, e com essa bagagem consegui um est�gio logo no in�cio do meu primeiro per�odo na faculdade.

Lucas Rodrigues

Estudo aqui na Dev desde o meio do ano passado! Nesse per�odo a Dev me ajudou a crescer muito aqui no trampo.
Fui o primeiro desenvolvedor contratado pela minha empresa. Hoje eu lidero um time de desenvolvimento!
Minha meta � continuar estudando e praticando para ser um Full-Stack Dev!

Her�clito J�nior

Economizei 3 meses para assinar a plataforma e sendo sincero valeu muito a pena, pois a plataforma � bem intuitiva e muuuuito did�tica a metodologia de ensino. Sinto que estou EVOLUINDO a cada dia. Muito obrigado!

Julio Cablen

Nossa! Plataforma maravilhosa. To amando o curso de desenvolvimento front-end, tinha coisas que eu ainda n�o tinha visto. A did�tica � do jeito que qualquer pessoa consegue aprender. S�rio, to apaixonado, adorando demais.

Joelberth Sena

Adquiri o curso de voc�s e logo percebi que s�o os melhores do Brasil. � um passo a passo incr�vel. S� n�o aprende quem n�o quer. Foi o melhor investimento da minha vida!

Felipe Nunes

Foi um dos melhores investimentos que j� fiz na vida e tenho aprendido bastante com a plataforma. Voc�s est�o fazendo parte da minha jornada nesse mundo da programa��o, irei assinar meu contrato como programador gra�as a plataforma.

Wanderson Oliveira

Comprei a assinatura tem uma semana, aprendi mais do que 4 meses estudando outros cursos. Exerc�cios pr�ticos que n�o tem como n�o aprender, est�o de parab�ns!

Jos� Lucas

Obrigado DevMedia, nunca presenciei uma plataforma de ensino t�o presente na vida acad�mica de seus alunos, parab�ns!

Eduardo Dorneles

Aprendi React na plataforma da DevMedia h� cerca de 1 ano e meio... Hoje estou h� 1 ano empregado trabalhando 100% com React!

Adauto Junior

J� fiz alguns cursos na �rea e nenhum � t�o bom quanto o de voc�s. Estou aprendendo muito, muito obrigado por existirem. Est�o de parab�ns... Espero um dia conseguir um emprego na �rea.

Ver todos os casos de sucesso

J2EE: Concorr�ncia na Plataforma Java EE 7

Veja neste artigo o que e como podemos utilizar a funcionalidade de concorr�ncia que est� especificada na plataforma Java EE 7. Tamb�m veremos diversos exemplos de como a concorr�ncia � tratada na plataforma Java EE 7.