Note du traducteur: Je pense personnellement que l'utilisation de tâches chronométrées pour exécuter la collecte des ordures n'est pas un bon exemple. Données, fichiers, etc.
Dans cet article, je présenterai 3 méthodes de mise en œuvre différentes:
1. Implémentation de fil ordinaire
2. Implémentation de Timertask
3. Implémentation ScheduleDExecutService
1. Fil ordinaire
C'est la chose la plus courante. Cela peut être implémenté rapidement et facilement, le code est le suivant:
La copie de code est la suivante:
classe publique Tâche1 {
public static void main (String [] args) {
// fonctionne dans une seconde
Final Long TimeInterval = 1000;
Runnable runnable = new runnable () {
public void run () {
while (true) {
// -------- Code pour la tâche à exécuter
System.out.println ("Hello !!");
// ---------- se termine ici
essayer {
Thread.sleep (timeInterval);
} catch (InterruptedException e) {
e.printStackTrace ();
}
}
}
};
Thread thread = nouveau thread (runnable);
thread.start ();
}
}
2. Utilisez la minuterie et la poubelle
L'implémentation ci-dessus est très rapide et facile, mais elle manque également de fonctionnalités.
Par rapport à la méthode ci-dessus, l'utilisation de la minuterie et de la tricère a les avantages suivants:
1. Contrôlé lors du démarrage et de l'annulation des tâches
2. Vous pouvez spécifier le temps de retard souhaité lors de l'exécution d'une tâche pour la première fois
Pendant la mise en œuvre, la classe de temporisation peut planifier des tâches et Timertask implémente des tâches spécifiques dans la méthode RUN ().
Les instances de temporisation peuvent planifier le multitâche, et il est en filetage.
Lorsque le constructeur de la minuterie est appelé, il crée un fil qui peut être utilisé pour planifier des tâches.
Voici le code:
La copie de code est la suivante:
import java.util.timer;
import java.util.timertask;
classe publique Tâche2 {
public static void main (String [] args) {
Tâche TIMERTASK = new Timertask () {
@Outrepasser
public void run () {
// La tâche à exécuter va ici
System.out.println ("Hello !!!");
}
};
Timer Timer = new Timer ();
long retard = 0;
longue période périodio = 1 * 1000;
// planifie la tâche à exécuter dans un intervalle
TIMER.ScheduleAtFixeDrate (tâche, retard,
Integerperiod);
} // Fin de la principale
}
Ces classes existent depuis JDK 1.3.
3. ScheduleDExecutService
ScheduleDexeCutorService a été introduit comme une classe d'outils simultanée de Java SE 5 Java.util.concurrent, qui est la méthode de mise en œuvre de la tâche chronométrée la plus idéale.
Par rapport aux deux méthodes ci-dessus, il présente les avantages suivants:
1. Comparé au thread unique de Timer, il exécute des tâches via un pool de threads.
2. Vous pouvez définir le temps de retard pour l'exécution de la première tâche
3. Fournir de bons accords pour définir l'intervalle de temps d'exécution
Ce qui suit est le code d'implémentation.
La copie de code est la suivante:
Importer java.util.concurrent.executors;
Importer java.util.concurrent.scheduleDExecutorService;
Importer java.util.concurrent.TimeUnit;
classe publique Tâche3 {
public static void main (String [] args) {
Runnable runnable = new runnable () {
public void run () {
// La tâche à exécuter va ici
System.out.println ("Hello !!");
}
};
Service ScheduleDexeCuTorService = Exécuteurs
.NewSingLetHreadScheduleDexecutor ();
Service.ScheduleAtFixeDrate (Runnable, 0, 1, timeunit.seconds);
}
}