DevMedia
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login

JSR 166 concurrent: Movendo o java para Frente com o java 7 - Parte 4

Nesse artigo será mostrado os novos recursos do pacote concurrent , que dará maior facilidade no desenvolvimento em processos paralelos.

[fechar]

Você não gostou da qualidade deste conteúdo?

(opcional) Você poderia comentar o que não lhe agradou?

Confirmo meu voto negativo

            Foi adicionada esse pacote para facilitar  aplicações que necessitem escalar ou realizar processos em paralelos.

            Umas das melhorias são as variáveis atômicas, uma variável atômica é que não pode ser dividida, é semelhante ao Sistema operacional que possui um recurso (um leitor usb, por exemplo) que não pode ser dividido, no entanto pode ser usado por vários processos ao mesmo tempo. Na listagem 11 é mostrado um exemplo simples de produtor e consumidor em que uma variável atômica é utilizada entre os dois processos.

 

           static class AtomicCounter {

         private AtomicInteger contador = new AtomicInteger(0);

         public void increment() {

             System.out.println("Incrementando " + contador.incrementAndGet());
         }
 
         public void decrement() {
             System.out.println("Decrementando " + contador.decrementAndGet());
 
         }
 
         public int value() {
             return c.get();
         }
     }
 
     static class Produtor implements Runnable {
 
         private AtomicCounter atomicCounter;
 
         public Produtor(AtomicCounter contador) {
             this.atomicCounter = contador;
 
 
         }
 
         @Override
         public void run() {
             while (true) {
 
                 try {
                     Thread.sleep(2000);
                 } catch (InterruptedException ex) {
                     ex.printStackTrace();
                 }
                 atomicCounter.increment();
 
 
             }
         }
     }
 
     static class Consumidor implements Runnable {
 
         private AtomicCounter atomicCounter;
 
         public Consumidor(AtomicCounter contador) {

            this.atomicCounter = contador;
 
 
         }
 
         @Override
         public void run() {
             while (true) {
 
                 try {
                     Thread.sleep(4000);
                 } catch (InterruptedException ex) {
                     ex.printStackTrace();
                 }
                 atomicCounter.decrement();
 
             }
         }
     }
 
     public static void main(String[] args) {
 
         AtomicCounter atomicCounter = new AtomicCounter();
         Thread consumidor = new Thread(new Consumidor(atomicCounter));
         Thread produtor = new Thread(new Produtor(atomicCounter));
         consumidor.start();
         produtor.start();
         while (true) {
         }
 
     }


Listagem11: exemplo simples de consumidor e produtor usando variável atômica

 

            É possível usar variáveis atômicas a partir de uma classe para isso basta que essa implemente o java.io.Serializable

    public static void main(String[] arg) {

         AtomicReference<MeuObjeto> meubojeto = new AtomicReference<>();

         System.out.println(meubojeto.get());//imprime nulo

         meubojeto.set(new MeuObjeto("valor Atributo"));

         System.out.println(meubojeto.get().getAtributo());//imprime valor Atributo

         AtomicReferenceArray<MeuObjeto> usuarios = new AtomicReferenceArray(10);

         // array atomico com o tamanho 10      

         usuarios.getAndSet(1, new MeuObjeto("Setando objeto 1"));

 

     }


Listagem 12: criando variáveis atômicas e array de Objetos criados

 

A partir desse novo jdk existem novas coleções concorrentes.

   BlockingDeque<MeuObjeto> fila = new LinkedBlockingDeque<>();

   ConcurrentMap<String, MeuObjeto> mapa = new ConcurrentHashMap();

 ConcurrentNavigableMap<String, MeuObjeto> maps = new ConcurrentSkipListMap<>();


Listagem 13: Collections concorrentes

 

            Com a concorrência de processos pode-se bloquear um  recurso impedindo que uma Thread acesse durante aquele momento para isso basta usar a classe java.util.concurrent.locks.Lock.

 

             O Executor tem como principal objetivo realizar processos paralelos de grande escala, nele é possível implementar três novas interfaces (Executor, ExecutorService, ScheduledExecutorService) para concorrência além da maioria das classes do pacote executam no pool de Threads, garantindo uma maior eficiência no gerenciamento de processos concorrentes dentro da jvm. Outro recurso é o Fork/Join que implementa a interface ExecutorService que ajuda a tirar proveito de múltiplos processamento, processos que possam ser divididos em menores e trabalhem de forma recursiva.

 

 

Conclusão:

 

 

Neste artigo foi abordado sobre as novidades da parte de concorrência do java 7, a pasta current, trouxe várias novidades para facilitar os processos paralelos.



Otávio Santana, o otaviojava, é desenvolvedor entusiasta do mundo Open-Source. Praticante da filosofia ágil e do desenvolvimento poliglota na Bahia, JUG Leader do JavaBahia, um dos fomentadores do grupo LinguÁgil. Presente nos mai [...]

O que você achou deste post?
Conhece a assinatura MVP?
Serviços

Mais posts