Timer-Klasse im Threading-Modul in Python

Threading ist die Technik, bei der mehrere Threads gleichzeitig ausgeführt werden, um Parallelität zu erreichen. In Python können wir Threading mit dem Modul threading implementieren. Jetzt hat das Modul threading eine Klasse Timer, die verwendet werden kann, um eine Aktion auszuführen oder einen Code nach x Zeit auszuführen. In diesem Artikel werden wir anhand eines Beispiels sehen, wie wir diese Klasse verwenden und besser verstehen können. Wir werden einen unendlichen Timer bauen.

Die threading.Timer-Klasse in Python

Die Klasse Timer ist eine Unterklasse der Klasse Thread und kann verwendet werden, um Code nach einigen Zeiteinheiten auszuführen. Es akzeptiert zwei Argumente, nämlich interval und function. intervall bezeichnet die Anzahl der Sekunden, nach denen der Code ausgeführt werden soll, und function ist die Callback-Funktion, die aufgerufen werden soll, wenn die erforderliche Zeit abgelaufen ist. Diese Klasse hat zwei wichtige Funktionen, nämlich start() und cancel(). Die Methode start() wird verwendet, um den Timer zu starten, und die Methode cancel() wird verwendet, um ihn abzubrechen.

Timer-Objekte werden standardmäßig nicht gestartet. Wir müssen die Methode start() aufrufen, um sie zu starten. Und um einen laufenden Timer zu stoppen, können wir die Methode cancel() verwenden.

Nun, da wir mit der Theorie fertig sind, wollen wir verstehen, wie wir diese Klasse praktisch verwenden können, um einen unendlichen Timer zu erstellen. Siehe den folgenden Code für dasselbe.

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()

Ausgabe:

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

Wie wir sehen, verwendet die Klasse MyInfiniteTimer die Klasse Timer. Es akzeptiert zwei Argumente: t und hFunction, die sich auf die Anzahl der Sekunden und die Callback-Funktion für das Timer-Objekt beziehen. Wenn ein Objekt der Klasse MyInfiniteTimer erstellt wird, erstellt der Konstruktor der Klasse ein neues Timer-Objekt, startet es jedoch nicht. Der Timer kann mit der Methode start() der Klasse MyInfiniteTimer gestartet werden. Und mit der Methode stop() kann der Timer gestoppt werden. Sobald der aktuelle Timer endet, erstellt der Handler oder die handle_function() einen neuen Timer mit den gleichen Konfigurationen wie der vorherige Timer und startet ihn.

Um die Funktionsweise der Klasse MyInfiniteTimer zu demonstrieren, haben wir zuerst in Zeile 29 ein neues Klassenobjekt MyInfiniteTimer erstellt und dann die Methode start() aufgerufen. Als nächstes warteten wir 5 Sekunden oder ließen den Timer 5 Sekunden laufen. Dann stoppten wir den Timer und warteten wieder 5 Sekunden. Zuletzt haben wir die letzten beiden Prozesse wiederholt, und dann wurde das Programm beendet.