Python定时器的一个实现

'''
Created on 2012-10-11

@author: blh
'''

import threading
import time

class PyTimer:
    PRECISION = 10  # 10ms
    
    def __init__(self, scheduler_num=1):
        self.lock = threading.Lock()
        self.schedulers = []
        self.scheduler_index = 0
        self.scheduler_num = scheduler_num

    def get_scheduler(self):    
        self.lock.acquire()
        index = self.scheduler_index
        self.scheduler_index = (self.scheduler_index + 1) % self.scheduler_num
        self.lock.release()
        return self.schedulers[index]

    def create(self, callback):
        return self.Timer(self, callback)
        
    def start(self):
        n = 0
        while n < self.scheduler_num:
            scheduler = self.Scheduler(n)
            scheduler.start()
            self.schedulers.append(scheduler)
            n += 1

    def stop(self):
        for scheduler in self.schedulers:
            scheduler.stop()
        
    def get_info(self):
        info = ''
        total = 0
        n = 1
        for scheduler in self.schedulers:
            count = scheduler.get_count()
            info += 'timer-{0}: {1}\n'.format(n, count)
            total += count
            n += 1
        info += 'timer total: {0}\n'.format(total)
        return info        
    
    class Timer:
        def __init__(self, manager, callback):
            self.manager = manager
            self.callback = callback
            self.scheduler = None
            self.timeout = True                   
    
        #intval unit is ms
        def set(self, intval):
            self.intval = int(intval / PyTimer.PRECISION)
            self.scheduler = self.manager.get_scheduler()            
            self.scheduler.set(self)
        
        def cancel(self):
            if self.scheduler:
                self.scheduler.cancel(self)

        def reset(self, intval):
            self.cancel()
            self.set(intval)
            
    class Scheduler(threading.Thread):                               
        QUEUE_NUM = 300

        def __init__(self, scheduler_id):
            threading.Thread.__init__(self)
            self.scheduler_id = scheduler_id
            self.lock = threading.Lock()
            self.queues = {}
            self.timers = {}
            self.current = 0
            self.running = True
            for n in range(self.QUEUE_NUM):
                self.queues[n] = []
        
        def get_offset(self, intval):
            offset = intval
            if offset >= self.QUEUE_NUM:
                offset = (self.QUEUE_NUM - 1)
            return offset
        
        def get_queue(self, offset):
            qid = (self.current + offset) % self.QUEUE_NUM
            return self.queues[qid]

        def enqueue(self, timer):
            offset = self.get_offset(timer.intval)
            timer.intval -= offset
            queue = self.get_queue(offset)
            self.timers[timer] = queue
            queue.append(timer)
        
        def dequeue(self, timer):
            if self.timers.has_key(timer):
                queue = self.timers.pop(timer)
                queue.remove(timer)
            
        def set(self, timer):
            assert(timer)
            self.lock.acquire()
            self.enqueue(timer)
            self.lock.release()
            return timer
        
        def cancel(self, timer):
            self.lock.acquire()
            self.dequeue(timer)
            self.lock.release()    
        
        def stop(self):
            self.running = False
        
        def run(self):
            base_time = float(PyTimer.PRECISION) / 1000
            sleep_time = base_time
            while self.running:
                if sleep_time > 0.0:
                    time.sleep(sleep_time)
                t1 = time.time()
                self.lock.acquire()
                queue = self.queues[self.current]
                while len(queue):
                    timer = queue.pop()
                    if timer.intval:
                        self.enqueue(timer)
                    else:
                        self.timeout(timer)
                self.current = (self.current + 1) % self.QUEUE_NUM
                self.lock.release()
                t2 = time.time()
                sleep_time = base_time - (t2 - t1)
            
        def timeout(self, timer):
            self.timers.pop(timer)
            self.lock.release()
            timer.callback()
            self.lock.acquire()

        def get_count(self):
            self.lock.acquire()
            count = len(self.timers)
            self.lock.release()
            return count

class TimerDemo:
    def __init__(self):
        self.timer = PyTimer()
        self.timer.start()
    
    def test(self):
        self.t1 = self.timer.create(self.timeout1s)
        self.t1.set(1000)
        self.t2 = self.timer.create(self.timeout3s)
        self.t2.set(3000)
        self.t3 = self.timer.create(self.timeout600ms)
        self.t3.set(600)


    def timeout1s(self):
        print 'timeout1s'
        self.t1.set(1000)
    
    def timeout3s(self):
        print 'timeout3s'
        self.t2.set(3000)
    
    def timeout600ms(self):
        print 'timeout600ms'
        self.t3.set(600)


if __name__ == '__main__':
    demo = TimerDemo()
    demo.test()