Clase Timer en el módulo Threading en Python

El subproceso es la técnica de ejecutar varios subprocesos al mismo tiempo para lograr el paralelismo. En Python, podemos implementar subprocesos usando el módulo threading. Ahora, el módulo threading tiene una clase Timer, que puede usarse para realizar alguna acción o ejecutar algún código después de x cantidad de tiempo. En este artículo, veremos cómo podemos usar esta clase y comprenderla mejor con la ayuda de un ejemplo. Construiremos un temporizador infinito.

La clase threading.Timer en Python

La clase Timer es una subclase de la clase Thread y se puede utilizar para ejecutar código después de algunas unidades de tiempo. Acepta dos argumentos, a saber, interval y function. interval se refiere al número de segundos después de los cuales se debe ejecutar el código, y function es la función de devolución de llamada que se debe llamar cuando haya transcurrido el tiempo requerido. Esta clase tiene dos funciones importantes, a saber, start() y cancel(). El método start() se utiliza para iniciar el temporizador y el método cancel() se utiliza para cancelarlo.

Los objetos de temporizador no se inician de forma predeterminada. Tenemos que llamar al método start() para lanzarlos. Y para detener un temporizador en ejecución, podemos usar el método cancel().

Ahora que hemos terminado con la teoría, entendamos cómo podemos usar esta clase de manera práctica para crear un temporizador infinito. Consulte el siguiente código para el mismo.

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

Producción :

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

Como podemos ver, la clase MyInfiniteTimer utiliza la clase Timer. Acepta dos argumentos: t y hFunction, que se refieren al número de segundos y la función de devolución de llamada para el objeto Timer. Cuando se crea un objeto de clase MyInfiniteTimer, el constructor de la clase crea un nuevo objeto de temporizador pero no lo inicia. El temporizador se puede iniciar utilizando el método start() de la clase MyInfiniteTimer. Y usando el método stop(), el temporizador se puede detener. Una vez que finaliza el temporizador actual, el controlador o el handle_function() crea un nuevo temporizador con las mismas configuraciones que el temporizador anterior y lo inicia.

Para mostrar el funcionamiento de la clase MyInfiniteTimer, primero creamos un nuevo objeto de clase MyInfiniteTimer en la línea 29 y luego llamamos al método start(). A continuación, esperamos 5 segundos o dejamos que el temporizador funcione durante 5 segundos. Luego paramos el temporizador y nuevamente esperamos por 5 segundos. Por último, repetimos los dos últimos procesos y luego el programa terminó.