Classe Timer dans le module Threading en Python

Le threading est la technique consistant à exécuter plusieurs threads simultanément pour obtenir le parallélisme. En Python, on peut implémenter le threading à l’aide du module threading. Maintenant, le module threading a une classe Timer, qui peut être utilisée pour effectuer une action ou exécuter du code après un laps de temps x. Dans cet article, nous allons voir comment utiliser cette classe et mieux la comprendre à l’aide d’un exemple. Nous allons construire une minuterie infinie.

La classe threading.Timer en Python

La classe Timer est une sous-classe de la classe Thread et peut être utilisée pour exécuter du code après quelques unités de temps. Il accepte deux arguments, à savoir interval et function. interval fait référence au nombre de secondes après lesquelles le code doit être exécuté, et function est la fonction de rappel qui doit être appelée lorsque le temps requis s’est écoulé. Cette classe a deux fonctions importantes, à savoir start() et cancel(). La méthode start() est utilisée pour démarrer le chronomètre et la méthode cancel() est utilisée pour l’annuler.

Les objets Timer ne démarrent pas par défaut. Il faut appeler la méthode start() pour les lancer. Et pour arrêter un chronomètre en cours d’exécution, nous pouvons utiliser la méthode cancel().

Maintenant que nous avons terminé avec la théorie, comprenons comment nous pouvons pratiquement utiliser cette classe pour créer un minuteur infini. Reportez-vous au code suivant pour la même chose.

from time import sleep
from threading import Timer
from datetime import datetime


class MyInfiniteTimer:
    """
    A Thread that executes infinitely
    """

    def __init__(self, t, hFunction):
        self.t = t
        self.hFunction = hFunction
        self.thread = Timer(self.t, self.handle_function)

    def handle_function(self):
        self.hFunction()
        self.thread = Timer(self.t, self.handle_function)
        self.thread.start()

    def start(self):
        self.thread = Timer(self.t, self.handle_function)
        self.thread.start()

    def cancel(self):
        self.thread.cancel()


def print_current_datetime():
    print(datetime.today())


t = MyInfiniteTimer(1, print_current_datetime)
t.start()
sleep(5)
t.cancel()
sleep(5)
t.start()
sleep(5)
t.cancel()

Production :

2021-10-31 05:51:20.754663
2021-10-31 05:51:21.755083
2021-10-31 05:51:22.755459
2021-10-31 05:51:23.755838
2021-10-31 05:51:24.756172
2021-10-31 05:51:30.764942
2021-10-31 05:51:31.765281
2021-10-31 05:51:32.765605
2021-10-31 05:51:33.766017
2021-10-31 05:51:34.766357

Comme on peut le voir, la classe MyInfiniteTimer utilise la classe Timer. Il accepte deux arguments : t et hFunction, qui font référence au nombre de secondes et à la fonction de rappel de l’objet Timer. Lorsqu’un objet de classe MyInfiniteTimer est créé, le constructeur de la classe crée un nouvel objet timer mais ne le démarre pas. Le timer peut être lancé à l’aide de la méthode start() de la classe MyInfiniteTimer. Et en utilisant la méthode stop(), le chronomètre peut être arrêté. Une fois le timer en cours terminé, le gestionnaire ou le handle_function() crée un nouveau timer avec les mêmes configurations que le timer précédent et le démarre.

Pour présenter le fonctionnement de la classe MyInfiniteTimer, nous avons d’abord créé un nouvel objet de classe MyInfiniteTimer à la ligne 29 puis appelé la méthode start(). Ensuite, nous avons attendu 5 secondes ou laissé le chronomètre fonctionner pendant 5 secondes. Ensuite, nous avons arrêté le chronomètre et avons de nouveau attendu 5 secondes. Enfin, nous avons répété les deux derniers processus, puis le programme s’est terminé.