Olá desenvolvedores, o objetivo deste tutorial é aprender a controlar uma thread iniciando-a e parando quando desejarmos. Este controle será feito a partir da tela implementada nos tutoriais passados.

Tencionando tornar esta experiência o mais real possível, e sem perder o cunho didático, desenvolvemos uma tela a qual implementamos dois botões, rótulos e campos de texto respectivamente. Assim poderemos iniciar ou parar o processamento da thread em qualquer tempo, porém, ela ficará atualizando até que a “matemos”.

CONTROLANDO O CAMPO DATA E HORA

Criaremos a thread para depois trabalharmos com ela como um objeto e para isso iremos implementar um Runnable. A interface Runnable nos possibilitará também escrever códigos mais enxutos.

private Runnable thread1 = new Runnable(){
}

Dentro de Runnable deveremos adicionar o método run(), responsável pela execução da thread.

public void run(){
}

E no escopo do método run() implementaremos um código que mediante o start irá atualizar data e hora sem parar até que uma instrução de parada seja enviada. E se esta atualização se dará até que uma instrução deparada seja enviada, ou seja até que “matemos” a thread, a estrutura de repetição a ser implementada é o laço de repetição while. 

While(true){
}

Mas queremos poder visualizar na tela a atualização dos segundos e minutos, e poderemos conseguir este efeito a partir da uma instrução que imprime um formato de data e hora. Essa instrução irá transformar a data e hora que serão passados para um formato especificado, e os retornará em um setText.

mostraTempo_01.setText(newSimpleDateFormat("dd/MM/yyy hh:mm.ss").
format(Calendar.getInstance().getTime()));

Detalhando um pouco mais a linha de código acima, temos um getTime passando um “Date”. Este “Date” será recebido e formatado pelo “format” que por sua vez retornará uma String para o setText.

E como a iteração do while acontece de forma muito rápida, será necessário forçar um intervalo de tempo, para que no decorrer do processamento o computador não trave. Assim, dentro do while chamaremos o sleep e informaremos uma pausa de um segundo entre cada iteração.

Thread.sleep(1000);
 

E como sempre é quando adicionamos o sleep, a IDE nos solicita que seja implementada uma exceção com o try/catch. Clicando na lâmpada a esquerda, o código será automaticamente preenchido. Fora da Runnable criaremos o objeto de thread, para que seja possível acessá-lo de todos os lugares dentro da sistema.

Private Thread thread1Time;

ASSOCIANDO OS BUTTONS AS SUAS FUNÇÕES

Precisamos agora associar os bottons, start e stop as suas respectivas funções. Isto é, adicionar os eventos de dar início ao processamento da thread e de “mata-la”. Então implementaremos um evento que indicará a ocorrência de uma ação definida por componente, ou seja, um button.

Em linhas gerais significa que o evento é passado para todos os objetos do ActionListener que foi implementado para receber esses eventos usando o método addActionListener do componente. O objeto que implementa o ActionListener interconecta este ao ActionEvent quando o mesmo ocorre.

jButton_01.addActionListener(new ActionListener() { 
}

Assim, dentro do ActionListener teremos um actionPerformed que em suma significa uma identificação de evento indicando que ocorreu uma ação significativa. E dentro teremos uma thread recebendo um Runnable, responsável pela execução do código que exibirá a data e hora atualizados. E por fim, implementaremos a linha de código responsável por “startar” a thread, que ficará processando o run() em segundo plano.

public void actionPerformed(ActionEvent e) {

     thread1Time = new Thread(thread1);
     thread1Time.start();
}

E de forma semelhante procederemos com a implementação do evento de parar o processamento da thread.

jButton_01.addActionListener(new ActionListener() { 
     
     public void actionPerformed(ActionEvent e){
          thread1Time.start();
     }
});

HABILITANDO E DESABILITANDO BUTTONS

Não faz sentido que ao executarmos o programa a tela abra com o botão stop habilitado, iremos então desabilitá-lo. Assim depois da adição do segundo evento, iremos adicionar a linha de código responsável por desabilitar o botão.

jButton2.setEnabled(false);

No entanto, quando startarmos o evento, o “stop” deverá ser automaticamente habilitado. Desse modo, dentro do ActionListener do referido botão, iremos desabilitar o botão de iniciar e habilitar o de parar.

jButton1.setEnabled(false);
jButton2.setEnabled(true);

Agora dentro do ActionListener do botão de parar, iremos proceder de forma contrária habilitar o botão de iniciar quando o botão de parar estiver desabilitado.

jButton1.setEnabled(true);
jButton2.setEnabled(false);

EM POUCAS PALAVRAS

O tutorial de hoje nos trouxe muitos novos conhecimentos, e de um jeito divertido estamos quase concluindo o nosso trabalho. A implementação da segunda thread é exatamente a mesma coisa, mudando apenas a referência ao campo e a thread. Fica para você o desafio da implementação. Você pode, por exemplo, mudar a máscara da data/hora da segunda thread de forma distingui-las. Eu fico por aqui, nos vemos no próximo tutorial.