def METHOD_NAME(self, blocking=True):
    """Execute events until the queue is empty.
    If blocking is False executes the scheduled events due to
    expire soonest (if any) and then return the deadline of the
    next scheduled call in the scheduler.
    When there is a positive delay until the first event, the
    delay function is called and the event is left in the queue;
    otherwise, the event is removed from the queue and executed
    (its action function is called, passing it the argument).  If
    the delay function returns prematurely, it is simply
    restarted.
    It is legal for both the delay function and the action
    function to modify the queue or to raise an exception;
    exceptions are not caught but the scheduler's state remains
    well-defined so run() may be called again.
    A questionable hack is added to allow other threads to run:
    just after an event is executed, a delay of 0 is executed, to
    avoid monopolizing the CPU when other threads are also
    runnable.
    """
    # localize variable access to minimize overhead
    # and to improve thread safety
    lock = self._lock
    q = self._queue
    delayfunc = self.delayfunc
    timefunc = self.timefunc
    pop = heapq.heappop
    while True:
        with lock:
            if not q:
                break
            time, priority, action, argument, kwargs = q[0]
            now = timefunc()
            if time > now:
                delay = True
            else:
                delay = False
                pop(q)
        if delay:
            if not blocking:
                return time - now
            delayfunc(time - now)
        else:
            action(*argument, **kwargs)
            delayfunc(0)   # Let other threads run