import timefrom threading import Timer
def test_timer():    print("start=======")    t1 = time.time()    time.sleep(3)    print("ok")    t2 = time.time()    t21 = t2 - t1    print('t21====', t21)
def async_test_timer():    Timer(1, test_timer, []).start()
if __name__ == "__main__":    tm1 = time.time()    time.sleep(1)    async_test_timer()    tm2 = time.time()    tm21 = tm2 - tm1    print('tm21=====', tm21)

tm21===== 1.0052900314331055start=======okt21==== 3.0050549507141113

class Timer(Thread):    """Call a function after a specified number of seconds:
            t = Timer(30.0, f, args=None, kwargs=None)            t.start()            t.cancel()     # stop the timer's action if it's still waiting
    """
    def __init__(self, interval, function, args=None, kwargs=None):        Thread.__init__(self)        self.interval = interval        self.function = function        self.args = args if args is not None else []        self.kwargs = kwargs if kwargs is not None else {}        self.finished = Event()

class Thread:    """A class that represents a thread of control.
    This class can be safely subclassed in a limited fashion. There are two ways    to specify the activity: by passing a callable object to the constructor, or    by overriding the run() method in a subclass.
    """
    _initialized = False    # Need to store a reference to sys.exc_info for printing    # out exceptions when a thread tries to use a global var. during interp.    # shutdown and thus raises an exception about trying to perform some    # operation on/with a NoneType    _exc_info = _sys.exc_info    # Keep sys.exc_clear too to clear the exception just before    # allowing .join() to return.    #XXX __exc_clear = _sys.exc_clear
    def __init__(self, group=None, target=None, name=None,                 args=(), kwargs=None, *, daemon=None):        """This constructor should always be called with keyword arguments. Arguments are:
        *group* should be None; reserved for future extension when a ThreadGroup        class is implemented.
        *target* is the callable object to be invoked by the run()        method. Defaults to None, meaning nothing is called.
        *name* is the thread name. By default, a unique name is constructed of        the form "Thread-N" where N is a small decimal number.
        *args* is the argument tuple for the target invocation. Defaults to ().
        *kwargs* is a dictionary of keyword arguments for the target        invocation. Defaults to {}.
        If a subclass overrides the constructor, it must make sure to invoke        the base class constructor (Thread.__init__()) before doing anything        else to the thread.
        """        assert group is None, "group argument must be None for now"        if kwargs is None:            kwargs = {}        self._target = target        self._name = str(name or _newname())        self._args = args        self._kwargs = kwargs        if daemon is not None:            self._daemonic = daemon        else:            self._daemonic = current_thread().daemon        self._ident = None        self._tstate_lock = None        self._started = Event()        self._is_stopped = False        self._initialized = True        # sys.stderr is not stored in the class like        # sys.exc_info since it can be changed between instances        self._stderr = _sys.stderr        # For debugging and _after_fork()        _dangling.add(self)