看完了MainEngine的代码，大概有一个了解以后。我们在初始化MainEngine的时候，要传入或者实例化一个事件引擎对象。

代码基本结构

按照惯例，我把所有的方法体折叠，只保留类和方法，先大概对这个类要实现的功能有一个基本的了解。然后再逐个深入。

class EventEngine:
    def __init__(self, interval: int = 1):
        pass

    def _run(self):
        pass

    def _process(self, event: Event):
        pass

    def _run_timer(self):
        pass

    def start(self):
        pass

    def stop(self):
        pass

    def put(self, event: Event):
        pass

    def register(self, type: str, handler: HandlerType):
        pass

    def unregister(self, type: str, handler: HandlerType):
        pass

    def register_general(self, handler: HandlerType):
        pass

    def unregister_general(self, handler: HandlerType):
        pass

这个EventEngine看起来要比MainEngin有点货，至少从方法名字上很难一目了然的猜测到方法的作用。脑海中浮过VC的消息循环，或者C#的事件委托，又或者PyQt5的事件和插槽，不会是和那个机制类似的东东吧。

__init__(self, interval: int = 1)

    def __init__(self, interval: int = 1):
        """
        Timer event is generated every 1 second by default, if
        interval not specified.
        """
        self._interval = interval
        self._queue = Queue()
        self._active = False
        self._thread = Thread(target=self._run)
        self._timer = Thread(target=self._run_timer)
        self._handlers = defaultdict(list)
        self._general_handlers = []

从初始化的代码中可以看到，EventEngine用到了两个线程Thread同时初始化了一个队列__queue。

register

    def register(self, type: str, handler: HandlerType):
        """
        Register a new handler function for a specific event type. Every
        function can only be registered once for each event type.
        """
        handler_list = self._handlers[type]
        if handler not in handler_list:
            handler_list.append(handler)

我们找到HandlerType的定义

HandlerType = Callable[[Event], None]

基本上可以理解到注册一个可以被回调的方法，就是把这个方法的type和方法传给EventEngine然后，EventEngine会把这个回调方法保存到_handlers[type]中的数组中。

unregister

    def unregister(self, type: str, handler: HandlerType):
        """
        Unregister an existing handler function from event engine.
        """
        handler_list = self._handlers[type]

        if handler in handler_list:
            handler_list.remove(handler)

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

正好和register相反的方法，把一个事件从列表中移除。

register_general

    def register_general(self, handler: HandlerType):
        """
        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)

这个方法相当于把一个不指定type的回调方法放入_general_handlers,跟他相反的方法：unregister_general

put

    def put(self, event: Event):
        """
        Put an event object into event queue.
        """
        self._queue.put(event)

这个是传入一个Event，然后把这个Event放入到一个队列中去
我们先来看看Event这个类。

class Event:
    """
    Event object consists of a type string which is used
    by event engine for distributing event, and a data
    object which contains the real data.
    """

    def __init__(self, type: str, data: Any = None):
        """"""
        self.type = type
        self.data = data

从以上的代码，我们可以基本猜测在vnpy的事件引擎中，过来一个类型的数据，然后把这个数据存放到队列。然后再通过某种机制，定时的去调用那些通过regisiter进来的EventHandler。而什么类型的数据进来，给什么样的Handler回调。应该是通过Type去对应的。接下来，我们继续深入。

start和stop

    def start(self):
        """
        Start event engine to process events and generate timer events.
        """
        self._active = True
        self._thread.start()
        self._timer.start()

    def stop(self):
        """
        Stop event engine.
        """
        self._active = False
        self._timer.join()
        self._thread.join()

设置_active状态，启动或者阻塞线程。

核心部分的代码

    def _run(self):
        while self._active:
            try:
                event = self._queue.get(block=True, timeout=1)
                self._process(event)
            except Empty:
                pass

    def _process(self, event: Event):
        
        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):
        
        while self._active:
            sleep(self._interval)
            event = Event(EVENT_TIMER)
            self.put(event)

通过核心代码代码，我们豁然开朗。原来就是启动了两个线程，一个线程不断的循环把所有接受到的Event取出来发送给需要它的Handler进行回调，另外一个线程不断定时成Event，然后这个Event可以定时回调某些Handler

总结

我总结成一个图片