VNPY事件引擎（EventEngine）源码解读

Event（事件）

首先要搞清楚什么是事件？

class Event:
    """
    Event object consists ofr a type string which is used
    by event engine for distibuting event, and a data
    object which contains the real data.
    事件类，事件引擎所管理的事件，由两个部分组成：
    type（事件类型，通俗来说就是事件名）：str类型，用于识别不同事件
    data（事件中保存的数据）：any类型，用于传输数据
    """
    def __init__(self, type: str, data: Any = None) -> None:
        """"""
        self.type: str = type
        self.data: Any = data

通过事件类，我们基本上可以得出结论：事件就是由事件类型（事件名）+事件携带的数据

思想设计图

EventEngine（事件引擎）

事件引擎用于管理事件，我们分三个部分依次来看：
事情引擎的初始化，事件的创建和执行，事件处理方法的注册和删除

事情引擎的初始化

    def __init__(self, interval: int = 1) -> None:
        """
        Timer event is generated every 1 second by default, if
        interval not specified.
        """
        
        self._queue: Queue = Queue()     #事件队列，所有的事件以先进先出的方式放入和取出
        self._thread: Thread = Thread(target=self._run)   #创建事件处理线程
        self._handlers: defaultdict = defaultdict(list) #事件处理函数字典，key-事件类型，value（list）-执行处理相应事件类型的方法列表
        
        self._active: bool = False       #事件引擎状态，True－处理事件队列中的事件，False－不处理
        self._interval: int = interval   #定时事件的产生频率，单位：秒，默认1秒
        self._timer: Thread = Thread(target=self._run_timer)  #创建定时事件产生线程
        self._general_handlers: List = []         #通用事件处理函数列表，所有事件类型都在执行此列表中的方法

如果觉得参数太多，可以先看核心，把核心参数弄懂，剩下的迎刃而解了。
最重要的是：
创建了事件队列（self._queue）、事件处理线程（self._thread）、事件处理方法字典（self._handlers）
还要再说一下self._handlers的数据类型，首先是一个字典（key和value），key（str）是事件类型，value(list)中保存了注册该事件类型的方法。

事件的创建和执行

启动和关闭线程

1.激活事件引擎
2.开启事件处理线程
3.开始定时事件产生线程

    def start(self) -> None:
        """
        Start event engine to process events and generate timer events.
        """
        self._active = True   #激活事件引擎
        self._thread.start()  #开启事件处理线程
        self._timer.start()   #开始定时事件产生线程

    def stop(self) -> None:
        """
        Stop event engine.
        停止事件引擎
        """
        self._active = False
        self._timer.join()
        self._thread.join()

事件的加入和处理

加入事件

    def put(self, event: Event) -> None:
        """
        Put an event object into event queue.
        将事件放入到事件引擎的队列中
        """
        self._queue.put(event)

处理事件
1.处理事件线程（_run()）一直执行，目的就是将事件队列中的事件取出然后交给_process()方法处理
2.处理也分为两步：1.特定事件类型的特定函数处理列表 2.通用的事件列表中的方法必须执行。

    def _run(self) -> None:
        """
        Get event from queue and then process it.
        将事件从事件队列中取出并且执行
        """
        while self._active:    #当事件引擎状态为True,循环依次从事件队列（self._queue）中取出事件，放到_process()方法中执行
            try:
                event: Event = self._queue.get(block=True, timeout=1)
                self._process(event)
            except Empty:  #当所有事件全部取出，self._queue中没有事件了，抛出Empty异常，继续循环
                pass

    def _process(self, event: Event) -> None:
        """
        First distribute event to those handlers registered listening
        to this type.
        首先将事件分配给事件处理字典，通过事件类型（事件名）在事件处理字典中进行匹配，得到对应事件处理函数列表，依次执行处理函数

        Then distribute event to those general handlers which listens
        to all types.
        然后将事件分配给通用事件处理函数列表，所有的事件都要执行通用事件处理函数列表中的方法
        """
        if event.type in self._handlers:
            [handler(event) for handler in self._handlers[event.type]]

        if self._general_handlers:
            [handler(event) for handler in self._general_handlers]

定时事件的产生

    def _run_timer(self) -> None:
        """
        Sleep by interval second(s) and then generate a timer event.
        每隔一秒钟产生一个定时事件，并且将其加入到事件队列中
        """
        while self._active:
            sleep(self._interval)
            event: Event = Event(EVENT_TIMER)
            self.put(event)

事件处理方法的注册和删除

某一事件类型的处理方法

 def register(self, type: str, handler: HandlerType) -> None:
        """
        Register a new handler function for a specific event type. Every
        function can only be registered once for each event type.

        type:事件类型（事件名）
        handler： 处理事件的回调方法
        为某一事件类型注册处理方法
        """
        handler_list: list = self._handlers[type]   # 1.通过事件类型获得当前事件的处理方法列表
        if handler not in handler_list:             # 2.判断处理方法是否已被注册
            handler_list.append(handler)            # 3.如果未被注册，则添加到当前事件的处理方法列表中

    def unregister(self, type: str, handler: HandlerType) -> None:
        """
        Unregister an existing handler function from event engine.
        删除某一事件类型处理方法，
        """
        handler_list: list = self._handlers[type]

        if handler in handler_list:
            handler_list.remove(handler)

        if not handler_list:
            self._handlers.pop(type)

所有事件类型的处理方法

    def register_general(self, handler: HandlerType) -> None:
        """
        Register a new handler function for all event types. Every
        function can only be registered once for each event type.
        注册通用事件处理方法（所有的事件都要执行）
        """
        if handler not in self._general_handlers:
            self._general_handlers.append(handler)#（不需要使用字典来识别特定的事件，直接将处理函数加到列表中）

    def unregister_general(self, handler: HandlerType) -> None:
        """
        Unregister an existing general handler function.
        删除通用事件处理方法
        """
        if handler in self._general_handlers:
            self._general_handlers.remove(handler)

其他

如有不对请指出，如有想法请评论。
如有帮助请评论点赞支持，您的支持就是我最大的动力。
如果转载没有进行拓展或改进，请不要转载。