Java Timer, TimerTask, tutoriel de classe de rappel avec exemple

Publié: 2021-02-04
Java Timer, TimerTask, tutoriel de classe de rappel avec exemple

java.util.Timer est une classe utilitaire qui peut être utilisée pour planifier l'exécution d'un thread à un certain moment dans le futur. La classe Java Timer peut être utilisée pour programmer une tâche à exécuter une seule fois ou à exécuter à intervalles réguliers.

java.util.TimerTask est une classe abstraite qui implémente l'interface Runnable et nous devons étendre cette classe pour créer notre propre TimerTask qui peut être planifiée à l'aide de la classe Java Timer .

La classe Timer est thread-safe et plusieurs threads peuvent partager un seul objet Timer sans avoir besoin de synchronisation externe. La classe Timer utilise java.util.TaskQueue pour ajouter des tâches à un intervalle régulier donné et à tout moment, il ne peut y avoir qu'un seul thread exécutant TimerTask, par exemple si vous créez un Timer à exécuter toutes les 10 secondes mais que l'exécution d'un seul thread prend 20 secondes, alors l'objet Timer continuera d'ajouter des tâches à la file d'attente et dès qu'un thread sera terminé, il notifiera la file d'attente et un autre thread commencera à s'exécuter.

Classe de minuterie Java

La classe Timer utilise les méthodes d'attente et de notification d'objet pour planifier les tâches. TimerTask est une abstract class et nous en héritons pour fournir une implémentation concrète. La classe TimerTask implements l' interface Runnable , c'est donc un thread et donc votre implémentation de TimerTask est également un thread.

Timer et TimerTask très simples Exemple : La tâche s'exécute une fois que 5 seconds se sont écoulées.

Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com . crunchify . tutorials ;
 
import java . util . Timer ;
import java . util . TimerTask ;
 
/**
* Author: Crunchify.com
*/
 
public class CrunchifyTimerTaskExample {
Timer timer ;
 
public CrunchifyTimerTaskExample ( int seconds ) {
timer = new Timer ( ) ;
timer . schedule ( new CrunchifyReminder ( ) , seconds * 1000 ) ;
}
 
class CrunchifyReminder extends TimerTask {
public void run ( ) {
System . out . format ( "Timer Task Finished..!%n" ) ;
timer . cancel ( ) ; // Terminate the timer thread
}
}
 
public static void main ( String args [ ] ) {
new CrunchifyTimerTaskExample ( 5 ) ;
System . out . format ( "Task scheduled.. Now wait for 5 sec to see next message..%n" ) ;
}
}

Résultat:

1
2
Task scheduled . . Now wait for 5 sec to see next message . .
Time ' s up !

Ce programme simple illustre les parties de base suivantes de l'implémentation et de la planification d'une tâche à exécuter par un thread de minuterie :

  • Implémentez une sous-classe personnalisée de TimerTask . La méthode run contient le code qui exécute la tâche. Dans cet exemple, la sous-classe est nommée CrunchifyReminder.
  • Créez un thread en instanciant la classe Timer .
  • Instanciez l'objet TimerTask ( new CrunchifyReminder() ).
  • Planifiez l'exécution de la tâche du minuteur.

Comment puis-je effectuer cette TimerTask à plusieurs reprises ?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package crunchify . com . tutorials ;
 
import java . util . Timer ;
import java . util . TimerTask ;
import java . awt . Toolkit ;
 
/**
* Author: Crunchify.com
* Java Timer and TimerTask - Reminder Class Tutorials
*/
 
public class CrunchifyTimerTaskExample {
 
// Toolkit This class is the abstract superclass of all actual implementations of the Abstract Window Toolkit.
// Subclasses of the Toolkit class are used to bind the various components to particular native toolkit implementations.
     Toolkit toolkit ;
 
     // Timer A facility for threads to schedule tasks for future execution in a background thread.
// Tasks may be scheduled for one-time execution, or for repeated execution at regular intervals.
     Timer timer ;
 
     public CrunchifyTimerTaskExample ( ) {
         toolkit = Toolkit . getDefaultToolkit ( ) ;
         timer = new Timer ( ) ;
 
         // schedule() Schedules the specified task for repeated fixed-delay execution, beginning after the specified delay.
// Subsequent executions take place at approximately regular intervals separated by the specified period.
         timer . schedule ( new CrunchifyReminder ( ) , 0 , // initial delay
                 1 * 1000 ) ; // subsequent rate
     }
 
     // TimerTask A task that can be scheduled for one-time or repeated execution by a Timer.
// A timer task is not reusable. Once a task has been scheduled for execution on a Timer or cancelled,
// subsequent attempts to schedule it for execution will throw IllegalStateException.
     class CrunchifyReminder extends TimerTask {
         int loop = 5 ;
 
         public void run ( ) {
             if ( loop > 0 ) {
             // beep() Emits an audio beep depending on native system settings and hardware capabilities.
                 toolkit . beep ( ) ;
                 System . out . format ( "Knock Knock..!\n" ) ;
                 loop -- ;
             } else {
                 toolkit . beep ( ) ;
                 System . out . format ( "\nThat's it.. Done..!" ) ;
 
                 // cancel() Terminates this timer, discarding any currently scheduled tasks. Does not interfere with a currently executing task (if it exists). Once a timer has been terminated,
// its execution thread terminates gracefully, and no more tasks may be scheduled on it.
                 timer . cancel ( ) ;
             }
         }
     }
 
     public static void main ( String args [ ] ) {
         new CrunchifyTimerTaskExample ( ) ;
         System . out . format ( "Task scheduled..!%n \n" ) ;
     }
}

Résultat:

1
2
3
4
5
6
7
8
9
Task scheduled . . !
 
Knock Knock . . !
Knock Knock . . !
Knock Knock . . !
Knock Knock . . !
Knock Knock . . !
 
That ' s it . . Done . . !

Par défaut, un programme continue de s'exécuter tant que ses threads de minuterie sont en cours d'exécution. Vous pouvez terminer un thread de minuterie de quatre manières :

  • Invoquez l' cancel sur la minuterie. Vous pouvez le faire à partir de n'importe où dans le programme, par exemple à partir de la méthode d' run d'une tâche de minuteur.
  • Transformez le thread du minuteur en « démon » en créant le minuteur comme ceci : new Timer(true) . Si les seuls threads restants dans le programme sont des threads démons, le programme se ferme.
  • Une fois l'exécution de toutes les tâches planifiées du minuteur terminée, supprimez toutes les références à l'objet Timer . Finalement, le thread du minuteur se terminera.
  • Appelez la méthode System.exit , qui fait sortir tout le programme (et tous ses threads).