Nota do tradutor: eu pessoalmente acho que o uso de tarefas cronometradas para executar a coleta de lixo não é um bom exemplo. dados, arquivos, etc.
Neste artigo, apresentarei três métodos diferentes de implementação:
1. Implementação de tópicos comuns
2. Implementação do TimerTask
3. Implementação de ScheduleDexecutorService
1. Tópico comum
Esta é a coisa mais comum. Isso pode ser implementado de maneira rápida e fácil, o código é o seguinte:
A cópia do código é a seguinte:
classe pública Task1 {
public static void main (string [] args) {
// correr em um segundo
TimeInterval final final = 1000;
Runnable runnable = new Runnable () {
public void run () {
while (true) {
// -------- Código para a tarefa executar
System.out.println ("Hello !!");
// ---------- termina aqui
tentar {
Thread.sleep (TimeInterval);
} catch (interruptedException e) {
E.PrintStackTrace ();
}
}
}
};
Thread Thread = novo thread (executável);
thread.start ();
}
}
2. Use timer e TimerTask
A implementação acima é muito rápida e fácil, mas também carece de alguma funcionalidade.
Comparado com o método acima, o uso de timer e TimerTask tem os seguintes benefícios:
1. Controlado ao iniciar e cancelar tarefas
2. Você pode especificar o tempo de atraso desejado ao executar uma tarefa pela primeira vez
Durante a implementação, a classe Timer pode agendar tarefas e o Timertosk implementa tarefas específicas no método run ().
As instâncias do timer podem agendar multitarefa e é segura por threads.
Quando o construtor do timer é chamado, ele cria um thread que pode ser usado para agendar tarefas.
Aqui está o código:
A cópia do código é a seguinte:
importar java.util.timer;
importar java.util.timertak;
classe pública Task2 {
public static void main (string [] args) {
Tarefa TimerTask = new TimerTask () {
@Override
public void run () {
// Tarefa para executar vai aqui
System.out.println ("Hello !!!");
}
};
Timer timer = new Timer ();
atraso longo = 0;
longo periodPeriod = 1 * 1000;
// agenda a tarefa a ser executada em um intervalo
Timer.ScheduleatFixedrate (tarefa, atraso,
Integerperiod);
} // Fim do principal
}
Essas classes existem desde o JDK 1.3.
3. ScheduledExecutorService
O ScheduleDexecutorService foi introduzido como uma classe de ferramentas simultâneas do Java SE 5 java.util.Concurrent, que é o método de implementação de tarefas cronometrado mais ideal.
Comparado com os dois métodos acima, ele tem os seguintes benefícios:
1. Comparado com o thread único do timer, ele executa tarefas através de um pool de threads.
2. Você pode definir o tempo de atraso para a primeira execução de tarefas
3. Forneça bons acordos para definir o intervalo de tempo de execução
A seguir, o código de implementação.
A cópia do código é a seguinte:
importar java.util.concurrent.executores;
importar java.util.concurrent.scheduledExecutorService;
importar java.util.Concurrent.TimeUnit;
classe pública Task3 {
public static void main (string [] args) {
Runnable runnable = new Runnable () {
public void run () {
// Tarefa para executar vai aqui
System.out.println ("Hello !!");
}
};
Serviço de ScheduleedExecutorService = Executores
.NewsingleThreadScheduledExecutor ();
Service.scheduleatfixedrate (runnable, 0, 1, timeUnit.SECONDS);
}
}