定时调度模块:sched

"""A generally useful event scheduler class.
事件调度器类

Each instance of this class manages its own queue.
'类的每一个实例独立管理自己的队列'
No multi-threading is implied; you are supposed to hack that
yourself, or use a single instance per application.
'不隐含多线程，你应该自己实现它或者每个应用程序使用单独一个实例'

Each instance is parametrized with two functions, one that is
supposed to return the current time, one that is supposed to
implement a delay.
'每个实例都用两个函数参数，一个函数返回当前时间，一个函数参数实现延时'
You can implement real-time scheduling by
substituting time and sleep from built-in module time, or you can
implement simulated time by writing your own functions.
'你可以通过替换内置时间模块的时间和休眠来实现实时调度，也可以一个通过编写自己的函数来实现模拟时间'
This can also be used to integrate scheduling with STDWIN events;
'也可以用于整合stdwin事件调度'
the delay function is allowed to modify the queue.  Time can be expressed as
integers or floating point numbers, as long as it is consistent.
'允许延时函数修队列. 时间可以表示为整数或浮点数，只要它是一致的'

Events are specified by tuples (time, priority, action, argument).
'事件是指定为(时间、优先级、动作、参数)的元组'
As in UNIX, lower priority numbers mean higher priority;
'在UNIX中，较小的数意味着更高的权限'
in this way the queue can be maintained as a priority queue.
以这种方式，维护一个优先队列
Execution of the event means calling the action function, passing it the argument
执行事件，意味着调用动作函数, 将参数序列argument 传递给它
sequence in "argument" (remember that in Python, multiple function
arguments are be packed in a sequence).
在python中，多个函数参数被打包在一个元组中
The action function may be an instance method so it
has another way to reference private data (besides global variables).
动作函数可能是一个实例方法，所以它有另一种引用私有变量(除了全局变量)的方式
"""

# XXX The timefunc and delayfunc should have been defined as methods
# XXX so you can define new kinds of schedulers using subclassing
# XXX instead of having to define a module or class just to hold
# XXX the global state of your particular time and delay functions.

import heapq
from collections import namedtuple

__all__ = ["scheduler"]

Event = namedtuple('Event', 'time, priority, action, argument')

class scheduler:
    def __init__(self, timefunc, delayfunc):
        """Initialize a new instance, passing the time and delay
        functions"""
        self._queue = []
        self.timefunc = timefunc
        self.delayfunc = delayfunc

    def enterabs(self, time, priority, action, argument):
        """Enter a new event in the queue at an absolute time.

        Returns an ID for the event which can be used to remove it,
        if necessary.

        """
        event = Event(time, priority, action, argument)
        heapq.heappush(self._queue, event)
        return event # The ID

    def enter(self, delay, priority, action, argument):
        """A variant that specifies the time as a relative time.

        This is actually the more commonly used interface.

        """
        time = self.timefunc() + delay
        return self.enterabs(time, priority, action, argument)

    def cancel(self, event):
        """Remove an event from the queue.

        This must be presented the ID as returned by enter().
        If the event is not in the queue, this raises ValueError.

        """
        self._queue.remove(event)
        heapq.heapify(self._queue)

    def empty(self):
        """Check whether the queue is empty."""
        return not self._queue

    def run(self):
        """Execute events until the queue is empty.
        '''开始执行事件知道队列为空'''

        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
        否则,时间移除队列，并开始执行动作函数,动作函数用argument作为参数
        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.
        未捕获的异常，但是计划程序状态仍是明确的，所以，run()程序可以再次被调用

        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.
        允许其他线程运行的一个奇妙的方式是:
        在执行一个事件之后，执行0s的延时，以避免有其他可运行的线程时，它独占CPU时间

        """
        # localize variable access to minimize overhead
        # 本地化变量， 以最小化开销
        # and to improve thread safety
        q = self._queue
        delayfunc = self.delayfunc
        timefunc = self.timefunc
        pop = heapq.heappop
        while q:
            time, priority, action, argument = checked_event = q[0]
            now = timefunc()
            if now < time:
                delayfunc(time - now)
            else:
                event = pop(q)
                # Verify that the event was not removed or altered
                # by another thread after we last looked at q[0].
                # 验证我们在最后看到q[0]后， 该时间未被其他线程删除或更改
                if event is checked_event:
                    action(*argument)
                    delayfunc(0)   # Let other threads run
                else:
                    heapq.heappush(q, event)

    @property
    def queue(self):
        """An ordered list of upcoming events.
        # 一个即将执行的事件的有序列表

        Events are named tuples with fields for:
            time, priority, action, arguments

        """
        # Use heapq to sort the queue rather than using 'sorted(self._queue)'.
        # With heapq, two events scheduled at the same time will show in
        # the actual order they would be retrieved.
        events = self._queue[:]
        return map(heapq.heappop, [events]*len(events))

　　我的练习测试：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
import time, sched                                                                                                                                                                             

def LOG(msg):
    print msg                                                                                                                                                                                  

def init():
    LOG(timenow())
    s = sched.scheduler(time.time, time.sleep)
    return s                                                                                                                                                                                   

def timenow():
    return time.time()                                                                                                                                                                         

def show_time(msg):
    sec = time.time()
    area = time.localtime(sec)
    tm = time.asctime(area)
    print ''.join(msg)+ tm                                                                                                                                                                     

def to_timestamp():
    t = (2016, 12, 15, 16, 34, 50, 0, 0, 0)
    return time.mktime(t)                                                                                                                                                                      

def periodic_task(s, delay, priority, periodic_task, action, argument):
    LOG(timenow())
    action(argument);
    s.enter(delay, priority, periodic_task, (s, delay, priority, periodic_task, action, argument))                                                                                             

def do_somethon_before_suicide():
    LOG('''it's the time to exit''')
    exit()                                                                                                                                                                                     

def suicide(s):
    s.enterabs(to_timestamp(), 0, do_somethon_before_suicide, ())                                                                                                                              

def mymain():
    s = init()                                                                                                                                                                                 

    suicide(s)
    periodic_task(s, 2, 0, periodic_task, show_time, ('time now is: ', ))
    s.run()                                                                                                                                                                               

if __name__ == '__main__':
    mymain()