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