Em nosso terceiro tutorial da séria sobre thread e programação paralela ou concorrente iremos implementar um recurso de execução de código em backgound. Ou em outras palavras o que chamamos de processamento paralelo. Processo este que acontece em segundo plano enquanto o programa está liberado para executar outras funções.

O código que executará em paralelo é um laço de repetição que disparará uma mensagem a cada 1500 milsegundos.

for(int pos = 0; pos < 5; pos++){
    System.out.println("Executando uma rotina de envio de e-mail");
    Thread.sleep(1500);
}

Da forma como implementamos o código acima, somente após a primeira interação é que a thread entrará em ação. Ou seja, depois da primeira interação, as seguintes acontecerão somente um segundo e meio (1500 milisegundos).

Após o laço de repetição que tem um thread sendo implementada em seu escopo, exibiremos uma mensagem, informando que a execução da rotina foi realizada com sucesso.

System.out.println("\nROTINA EXECUTADA COM SUCESSO!!");

Trata-se de uma mensagem que será exibida tão somente após a conclusão do processamento da estrutura de repetição for. E até aí tudo bem, uma vez que esta mensagem informa ao usuário que a rotina chegou ao fim e foi completada com sucesso.

E se após esta mensagem implementássemos uma rotina ou uma instrução que exigiria uma interação do usuário do sistema? E mais, se a rotina que utiliza a thread sleep fosse uma rotina demorada?

No cenário de um sistema de gestão de vendas, o exposto acima implicaria em um cliente impaciente esperando por um longo tempo enquanto cada rotina é processada separadamente. Quando poderiam ter sido “startadas” simultaneamente e processadas em background, enquanto o operador do sistema seguia com outras tarefas.

THREADS EM BACKGROUNDS

Então como proceder para colocar a nossa pseudo “rotina de envio de e-mail”, rodando em paralelo? Vamos a implementação. O primeiro passo é instanciar uma nova thread onde ao final escreveremos a instrução .start(). É esta instrução que vai ligar a thread ao código que será processado em segundo plano.

new Thread(){
}.start();

Dentro do escopo da thread chamaremos o método run, que é o responsável por executar o código que ficará “rodando” em segundo plano. O que faremos então é mover o for, para dentro do método run.

new Thread(){

   public void run(){
     for(int pos = 0; pos < 5; pos++){
       System.out.println("Executando rotina de envio de e-mail");
       Thread.sleep(1500);
     }
   }
}

Observe que a IDE acusará um erro na linha do sleep. O Eclipse IDE solicitará que o sleep seja envolvido em um bloco de try/catch.

E fora do escopo de implementação da Thread, imprimiremos uma mensagem em uma janela gráfica. Esta janela simulará o fluxo normal do sistema enquanto ao código de simulação de envio de e-mail segue sendo executado em segundo plano.

JOptionPane.ShowConfirmDiolog(“FLUXO NORMAL DE PROCESSAMENTO DO SISTEMA CONTINUA EM EXCUÇÃO”);

Em um segundo a mensagem será exibida na tela, e em segundo plano poderemos acompanhar o fluxo de processamento do código.

EM POUCAS PALAVRAS

Obviamente que o que estamos fazendo trata-se de uma simulação, e bem simples. Entretanto, é o suficiente para a compreensão da lógica por trás da implementação de threads. Ao entender os porquês e como, você estará preparado para implementações mais complexas. Eu fico por aqui, nos vemos no próximo tutorial.