Olá desenvolvedores, hoje prosseguiremos com a Implementação do processo de Fila e Pilha com Thread. No tutorial passado começamos nosso aprendizado sobre Filas e Pilhas. Aprendemos que quando se trata de filas o primeiro elemento a entrar é o primeiro elemento a sair. Ao passo que em pilhas o último a entrar é o primeiro a sair.

Implementamos e preparamos toda a estrutura para adicionar dados à fila, processar (pelo método run()) e remover. Para isso recorremos ao uso da classe ConcurrentLinkedQueue, utilizada essencialmente em processamento paralelo ou concorrente junto com as threads. E para percorrer a lista promovendo iteração utilizamos o framework padrão do Java, o Iterator.

Dentro do laço de repetição while, que aliás faz parte do escopo do método synchronized, ficou estabelecido que enquanto existisse dados na fila o processamento continuaria. A função do synchronized é impedir que outros processos tenham acesso a lista prejudicando o seu processamento.

E por fim, pensando na limpeza da memória implementamos duas threads sleep. Com esta implementação determinamos um tempo entre o processamento de um dado e outro e ao final do laço de repetição.

E para que possamos implementar o processo de filas e pilhas com threads, iremos modificar a tela que já temos pronta. As modificações objetivam tornar possível que por meio da tela possamos adicionar dados para a lista. Nossa intenção é exemplificar a implementação do processamento de uma grande massa de dados.

MODIFICANDO A INTERFACE GRÁFICA DO SISTEMA

A primeira providência é, apagar as threads implementadas na classe TelaTimeThread, bem como toda as referências a ela apontadas pela IDE. Apagaremos também todos os “enableds”. Já aproveitando para alterar também os rótulos (labels), adequando-os. Agora ao executar teremos a nossa tela com todos os campos e botões habilitados, diferente de como havíamos deixado anteriormente.

Note que alteramos também o nome do botão, visto que agora iremos adicionar os dados a lista sempre que clicarmos no botão “ADD LISTA”.

Pegaremos a implementação “ImplementacaoFilaThread” e a partir dela criaremos um objeto, dessa forma quando a tela for instanciada já teremos o objeto “fila” criado dentro dela.

private ImplementacaoFilaThread fila = new ImplementacaoFilaThread();

E podemos testar para verificarmos se realmente nossa thread está rodando, então imprimiremos uma simples mensagem no console. Assim, no método responsável pela execução da thread, o run(), implemente o método print com uma mensagem qualquer.

System.out.println(“FILA RODANDO”);

Porém, lembre-se de “startar” a thread. Ou seja, na classe TelaTimeThread, antes do setVisible, inicie a “fila”.

fila.start();

Se tudo estiver correto, tão logo executemos o código a mensagem será exibida em segundo plano.

IMPLEMENTANDO AS FILAS

O passo seguinte e o mais legal é escrever o código que irá possibilitar adicionar os dados a lista.

Quando clicamos no botão “ADD LISTA”, executamos o ActionListener responsável por receber o evento. O ActionListener implementa um actionPerformed que identifica a ocorrência de um evento. É dentro do actionPerformed que instanciaremos o ObjetoFilaThread que receberá os dados de nome e e-mail.

ObjetoFilaThread filaThread = new ObjetoFilaThread();

filaThread.setNome(mostraTempo1.getText());
filaThread.setEmail(mostraTempo2.getText());

Os mostraTempo1 e mostraTempo2 são os identificadores do campo de texto por meio do qual passaremos os dados.

Agora com o objeto que controla a fila para que possa receber o objeto com os dados da tela e adicioná-los a lista/fila.

fila.add(filaThread);

No tutorial anterior, deixamos a estrutura para imprimir no console pronta, onde no método run() pegaremos os dados inseridos e imprimiremos.

System.out.println("NOME..: " +processar.getNome());
System.out.println("E-MAIL: " +processar.getEmail());

Lembrando que também no tutorial anterior, foi necessário mover o Interator para dentro do bloco synchronized que por sua vez foi envolvido por um novo bloco while. O while possibilitará o processamento e a sincronização enquanto houver dados para serem processados.

while(true) {

   synchronized(pilha_fila){
     Iterator iteracao = pilha_fila.iterator();

     while(iteracao.hasNext()){
     }
}}

Ao executarmos, poderemos adicionar os dados enquanto desejarmos. Isto é, poderemos tanto adicionar novos dados como adicionar os mesmos, apenas clicando seguidamente no “AD LISTA”. E assim, enquanto estes dados estiverem sendo processados, o sistema estará liberado para executar outras tarefas.

EM POUCAS PALAVRAS

Colocamos nossa thread para rodar com sucesso, os exemplos embora pareçam simples, irão fornecer toda a base necessária. É importante que você reveja estas aulas sobre threads, e tente implementar sozinho, recorra aos tutoriais e as aulas sempre que tiver dúvida. Mas pratique, o segredo está em praticar continuamente. Eu fico por aqui, nos vemos no próximo tutorial.