Uso das classes Timer e TimerTask

Criação de Timers

• Discutimos o uso de objetos que usam threads internamente para fazer seu trabalho
• Exemplo: Timer usado para escalonar tarefas
• Objetos da classe java.util.Timer escalonam instaâncias da classe TimerTask
• Eis um exemplo de um programa que realiza uma tarefa depois de um certo atraso

import java.util.Timer;
import java.util.TimerTask;

/**
 * Simple demo that uses java.util.Timer to schedule a task 
 * to execute once 5 seconds have passed.
 */

public class Reminder {
    Timer timer;

    public Reminder(int seconds) {
        timer = new Timer();
        timer.schedule(new RemindTask(), seconds*1000);
    }

    class RemindTask extends TimerTask {
        public void run() {
            System.out.println("Time's up!");
            timer.cancel(); //Terminate the timer thread
        }
    }

    public static void main(String args[]) {
        new Reminder(5);
        System.out.println("Task scheduled.");
    }
}

• Quando você rodar o exemplo, vai ver:

Task scheduled.
(depois de 5 segundos)
Time's up!

• O programa ilustra o uso de um "Timer Thread" para executar uma tarefa
  • Implementamos um subclasse de TimerTask e especificamos o que fazer no método run()
  • Criamos um thread através da instanciação de Timer
    • Está claro para você que deve haver um segundo thread em Timer? O que ocorreria se usássemos Thread.sleep(5000) diretamente?
  • Instanciamos o TimerTask (new RemindTask())
  • Escalonamos a execução da tarefa com o método schedule
    • O método schedule faz thread.sleep(5000) em outro thread
  • Também podemos executar a tarefa num momento específico:

    //Get the Date corresponding to 11:01:00 pm today.
    Calendar calendar = Calendar.getInstance();
    calendar.set(Calendar.HOUR_OF_DAY, 23);
    calendar.set(Calendar.MINUTE, 1);
    calendar.set(Calendar.SECOND, 0);
    Date time = calendar.getTime();

    timer = new Timer();
    timer.schedule(new RemindTask(), time);

Parando Timer Threads

• Normalmente, um programa executa enquanto os threads estiverem executando
• Há 4 formas de terminar um Timer thread:
  • timer.cancel()
  • Faça com que o Timer thread seja um "daemon" criando o timer assim: new Timer(true)
    • Um "daemon" é algo que roda como serviço: quando não há mais quem possa usar o serviço, o próprio serviço pode morrer
    • Se apenas threads do tipo daemon estiver no ar, o programa termina
  • Após a execução das tarefas do Timer thread, remova todas as referências ao timer
  • Chame o método System.exit()
    • O programa inteiro, com todos seus threads termina
• O programa acima usa a primeira forma de terminar o thread
  • Fazer com que o thread seja um daemon thread não funcionaria (por quê?)
• Às vezes, o programa não consegue terminar por causa de outros threads (além dos Timer threads)
  • Exemplo: se usar AWT, nem que seja para beepar, AWT vai criar um thread (não daemon) e manter o programa vivo
  • O exemplo abaixo precisa de System.exit() para o programa terminar

public class ReminderBeep {
    ...
    public ReminderBeep(int seconds) {
        toolkit = Toolkit.getDefaultToolkit();
        timer = new Timer();
        timer.schedule(new RemindTask(), seconds*1000);
    }
    class RemindTask extends TimerTask {
        public void run() {
            System.out.println("Time's up!");
            toolkit.beep();
            //timer.cancel(); // Not necessary because
                              // we call System.exit
            System.exit(0);   // Stops the AWT thread
                              // (and everything else)
        }
    }
    ...
}

Execução repetida de uma tarefa

• No exemplo abaixo, a tarefa é repetida 1 vez por segundo

public class AnnoyingBeep {
    Toolkit toolkit;
    Timer timer;

    public AnnoyingBeep() {
        toolkit = Toolkit.getDefaultToolkit();
        timer = new Timer();
        timer.schedule(new RemindTask(),
                       0,        //initial delay
                       1*1000);  //subsequent rate
    }

    class RemindTask extends TimerTask {
        int numWarningBeeps = 3;
        public void run() {
            if (numWarningBeeps > 0) {
                toolkit.beep();
                System.out.println("Beep!");
                numWarningBeeps--;
            } else {
                toolkit.beep(); 
                System.out.println("Time's up!");
                //timer.cancel(); // Not necessary because
                                  // we call System.exit
                System.exit(0);   // Stops the AWT thread 
                                  // (and everything else)
            }
        }
    }
    ...
}

• A saída deve ser assim:

Task scheduled.
Beep!      
Beep!      (one second after the first beep)
Beep!      (one second after the second beep)
Time's up! (one second after the third beep)

• Os métodos schedule que podem ser chamados para execução repetida são os seguintes:

    schedule(TimerTask task, long delay, long period)
    schedule(TimerTask task, Date time, long period)
    scheduleAtFixedRate(TimerTask task, long delay, long period)
    scheduleAtFixedRate(TimerTask task, Date firstTime, long period) 

• Nos métodos acima:
  • schedule(...) usam delays fixos e o periodo pode portanto ser maior que o pedido
  • scheduleAtFixedRate(...) usam delays variáveis de forma a manter os periodos fixos

programa