游戏算法-时间轮算法，简单时间轮python

简单时间轮，所有时间点的事件都有一个确定的槽位列表

达到当前时间点，执行槽位链表所有的事件即可

时间复杂度

增：O(1)

减：约为O(n)

执行事件：约为O(1)

优点：占用资源少、简单

缺点：不能延时超过最大刻度，需要升级为多重时间轮

使用场合：有最大值确定时间的，比如10秒最多访问n次

代码simolewheel.py

# coding: utf-8


 
class SimpleWheel(object):
    wheel_ptr_max = 60  # 最大刻度
    scale = 1  # 一刻度时间单位
 
    def __init__(self):
        self.ptr = 0  # 小轮当前刻度
        self.slots = [None] * self.wheel_ptr_max  # [[事件]]
        self.unique_id = 0  # 自增唯一ID，用于删除节点
        
    def inc_unique_id(self):
        self.unique_id += 1
        return self.unique_id
        
    def on_tick(self):
        self.ptr += 1
        if self.ptr >= self.wheel_ptr_max:
            self.ptr = 0
        self.cal_timer()
    
    def cal_timer(self):
        head = self.slots[self.ptr]
        self.slots[self.ptr] = None
        while head:
            print(head.call())
            head = head.next
    
    def start(self):
        # 开始时间轮
        self.cal_timer()
    
    def clear(self):
        # 清除
        self.slots = []
        self.ptr = 0
        self.unique_id = 0
        
    def add(self, func, sec):
        # 增加定时事件 O(n), 不可插入大于wheel_ptr_max时间
        if sec >= self.wheel_ptr_max:
            return
            
        ptr = self.ptr + sec % self.wheel_ptr_max
        node = SlotNode(func, self.inc_unique_id(), self.slots[ptr])
        self.slots[ptr] = node
        print("add {0} sec event, ptr: {1}, node.uid: {2}".format(sec, ptr, node.uid))
        return ptr, node.uid
        
    def remove(self, key):
        # 删除定时事件, 复杂度O(n)
        ptr, uid = key
        node = self.slots[ptr]
        if node.uid == uid:
            new_node = node.next
            node.next = None
            self.slots[ptr] = new_node
            print("remove: {0}".format(node.uid))
        else:
            next_node = node.next
            last = node
            while new_node:
                if new_node.uid == uid:
                    print("remove: {0}".format(new_node.uid))
                    last.next = new_node.next
                    new_node.next = None
                    break


# 事件节点
class SlotNode(object):
    def __init__(self, func, uid, next=None):
        self.uid = uid
        self.func = func
        self.next = next
 
    def call(self):
        return self.func(), "uid:", self.uid
        

测试文件

# coding: utf-8
 
import threading
import simplewheel
import time
 
def func():
    return "func run, time: {0}".format(time.time() - start_time)
    
start_time = time.time()  # 调试用
 
 
wheel_ob = simplewheel.SimpleWheel()
 
def tick():
    wheel_ob.on_tick()
    handler = threading.Timer(simplewheel.SimpleWheel.scale, tick)
    handler.start()
 
 
wheel_ob.add(func, 1)
wheel_ob.add(func, 2)
key = wheel_ob.add(func, 5)
wheel_ob.add(func, 15)
wheel_ob.add(func, 10)
wheel_ob.add(func, 20)
wheel_ob.remove(key)
print(wheel_ob.slots)
wheel_ob.start()
handler = threading.Timer(simplewheel.SimpleWheel.scale, tick)
handler.start()