【python】详解事件驱动event实现

所有的计算机程序都可以大致分为两类：脚本型（单次运行）和连续运行型（直到用户主动退出）。

1.脚本型：脚本型的程序包括最早的批处理文件以及使用Python做交易策略回测等等，这类程序的特点是在用户启动后会按照编程时设计好的步骤一步步运行，所有步骤运行完后自动退出。
2.连续运行型：连续运行型的程序包含了操作系统和绝大部分我们日常使用的软件等等，这类程序启动后会处于一个无限循环中连续运行，直到用户主动退出时才会结束。
一、连续运行型程序
我们要开发的交易系统就是属于连续运行型程序，而这种程序根据其计算逻辑的运行机制不同，又可以粗略的分为时间驱动和事件驱动两种。

1.1 时间驱动
时间驱动的程序逻辑相对容易设计，简单来说就是让电脑每隔一段时间自动做一些事情。这个事情本身可以很复杂、包括很多步骤，但这些步骤都是线性的，按照顺序一步步执行下来。

  1. from time import sleep
  2. def demo():
  3.     print(\'BB\')
  4. while True:
  5.     demo()
  6.     sleep(1.0)

时间驱动的程序本质上就是每隔一段时间固定运行一次脚本。尽管脚本自身可以很长、包含非常多的步骤，但是我们可以看出这种程序的运行机制相对比较简单、容易理解。

时间驱动的程序在量化交易方面还存在一些其他的缺点：如浪费CPU的计算资源、实现异步逻辑复杂度高等等。

1.2 事件驱动
与时间驱动对应的就是事件驱动的程序：当某个新的事件被推送到程序中时，程序立即调用和这个事件相对应的处理函数进行相关的操作。

举个例子：
有些人喜欢的某个公众号，然后去关注这个公众号，哪天这个公众号发布了篇新的文章，没多久订阅者就会在微信里收到这个公众号推送的新消息，如果感兴趣就打开来阅读。

上面公众号例子可以翻译为，监听器（订阅者）监听了（关注了）事件源（公众号），当事件源的发送事件时（公众号发布文章），所有监听该事件的监听器（订阅者）都会接收到消息并作出响应（阅读文章）。

  • 公众号为事件源
  • 订阅者为事件监听器
  • 订阅者关注公众号，相当于监听器监听了事件源
  • 公众号发布文章这个动作为发送事件
  • 订阅者收到事件后，做出阅读文章的响应动作

事件驱动主要包含以下元素和操作函数：

1.2.1 元素

  • 事件源
  • 事件监听器
  • 事件对象

1.2.2 操作函数

  • 监听动作
  • 发送事件
  • 调用监听器响应函数

现在用python实现来实现上述的业务逻辑，先看流程图：

1.2.3 EventManager事件管理类代码如下：

  1. # -*- coding: utf-8 -*-
  2. """
  3. Created on Tue Nov 13 13:51:31 2018
  5. @author: 18665
  6. """
  7. # 系统模块
  8. from queue import Queue, Empty
  9. from threading import *
  10. ########################################################################
  11. class EventManager:
  12.     #----------------------------------------------------------------------
  13.     def __init__(self):
  14.         """初始化事件管理器"""
  15.         # 事件对象列表
  16.         self.__eventQueue = Queue()
  17.         # 事件管理器开关
  18.         self.__active = False
  19.         # 事件处理线程
  20.         self.__thread = Thread(target = self.__Run)
  21.         self.count = 0
  22.         # 这里的__handlers是一个字典，用来保存对应的事件的响应函数
  23.         # 其中每个键对应的值是一个列表，列表中保存了对该事件监听的响应函数，一对多
  24.         self.__handlers = {}
  25.     #----------------------------------------------------------------------
  26.     def __Run(self):
  27.         """引擎运行"""
  28.         print(\'{}_run\'.format(self.count))
  29.         while self.__active == True:
  30.             try:
  31.                 # 获取事件的阻塞时间设为1秒
  32.                 event = self.__eventQueue.get(block = True, timeout = 1)  
  33.                 self.__EventProcess(event)
  34.             except Empty:
  35.                 pass
  36.             self.count += 1
  37.     #----------------------------------------------------------------------
  38.     def __EventProcess(self, event):
  39.         """处理事件"""
  40.         print(\'{}_EventProcess\'.format(self.count))
  41.         # 检查是否存在对该事件进行监听的处理函数
  42.         if event.type_ in self.__handlers:
  43.             # 若存在，则按顺序将事件传递给处理函数执行
  44.             for handler in self.__handlers[event.type_]:
  45.                 handler(event)
  46.         self.count += 1
  47.     #----------------------------------------------------------------------
  48.     def Start(self):
  49.         """启动"""
  50.         print(\'{}_Start\'.format(self.count))
  51.         # 将事件管理器设为启动
  52.         self.__active = True
  53.         # 启动事件处理线程
  54.         self.__thread.start()
  55.         self.count += 1
  56.     #----------------------------------------------------------------------
  57.     def Stop(self):
  58.         """停止"""
  59.         print(\'{}_Stop\'.format(self.count))
  60.         # 将事件管理器设为停止
  61.         self.__active = False
  62.         # 等待事件处理线程退出
  63.         self.__thread.join()
  64.         self.count += 1
  65.     #----------------------------------------------------------------------
  66.     def AddEventListener(self, type_, handler):
  67.         """绑定事件和监听器处理函数"""
  68.         print(\'{}_AddEventListener\'.format(self.count))
  69.         # 尝试获取该事件类型对应的处理函数列表，若无则创建
  70.         try:
  71.             handlerList = self.__handlers[type_]
  72.         except KeyError:
  73.             handlerList = []
  74.             self.__handlers[type_] = handlerList
  75.         # 若要注册的处理器不在该事件的处理器列表中，则注册该事件
  76.         if handler not in handlerList:
  77.             handlerList.append(handler)
  78.         print(self.__handlers)
  79.         self.count += 1
  80.     #----------------------------------------------------------------------
  81.     def RemoveEventListener(self, type_, handler):
  82.         """移除监听器的处理函数"""
  83.         print(\'{}_RemoveEventListener\'.format(self.count))
  84.         try:
  85.             handlerList = self.handlers[type_]
  86.             # 如果该函数存在于列表中，则移除
  87.             if handler in handlerList:
  88.                 handlerList.remove(handler)
  89.             # 如果函数列表为空，则从引擎中移除该事件类型
  90.             if not handlerList:
  91.                 del self.handlers[type_]
  92.         except KeyError:
  93.             pass
  94.         self.count += 1
  95.     #----------------------------------------------------------------------
  96.     def SendEvent(self, event):
  97.         """发送事件，向事件队列中存入事件"""
  98.         print(\'{}_SendEvent\'.format(self.count))
  99.         self.__eventQueue.put(event)
  100.         self.count += 1
  101. ########################################################################
  102. """事件对象"""
  103. class Event:
  104.     def __init__(self, type_=None):
  105.         self.type_ = type_      # 事件类型
  106.         self.dict = {}          # 字典用于保存具体的事件数据

1.2.4 测试代码

  1. # -*- coding: utf-8 -*-
  2. """
  3. Created on Tue Nov 13 13:50:45 2018
  5. @author: 18665
  6. """
  7.  
  8. # encoding: UTF-8
  9. import sys
  10. from datetime import datetime
  11. from threading import *
  12. #sys.path.append(\'D:\\works\\TestFile\')
  13. #print(sys.path)
  14. from eventManager import *
  15.  
  16. #事件名称  新文章
  17. EVENT_ARTICAL = "Event_Artical"
  18.  
  19. #事件源 公众号
  20. class PublicAccounts:
  21.     def __init__(self,eventManager):
  22.         self.__eventManager = eventManager
  24.     def WriteNewArtical(self):
  25.         #事件对象，写了新文章
  26.         event = Event(type_=EVENT_ARTICAL)
  27.         event.dict["artical"] = u\'如何写出更优雅的代码\n\'
  28.         
  29.         #发送事件
  30.         self.__eventManager.SendEvent(event)
  31.         print(u\'公众号发送新文章\n\')
  33. #监听器 订阅者
  34. class Listener:
  35.     def __init__(self,username):
  36.         self.__username = username
  38.     #监听器的处理函数 读文章
  39.     def ReadArtical(self,event):
  40.         print(u\'%s 收到新文章\' % self.__username)
  41.         print(u\'正在阅读新文章内容：%s\'  % event.dict["artical"])
  43. """测试函数"""
  44. #--------------------------------------------------------------------
  45. def test():
  46.     # 实例化监听器
  47.     listner1 = Listener("thinkroom") #订阅者1
  48.     listner2 = Listener("steve")     #订阅者2
  49.     # 实例化事件操作函数
  50.     eventManager = EventManager()
  52.     #绑定事件和监听器响应函数(新文章)
  53.     eventManager.AddEventListener(EVENT_ARTICAL, listner1.ReadArtical)
  54.     eventManager.AddEventListener(EVENT_ARTICAL, listner2.ReadArtical)
  55.     # 启动事件管理器,# 启动事件处理线程
  56.     eventManager.Start()
  58.     publicAcc = PublicAccounts(eventManager)
  59.     timer = Timer(2, publicAcc.WriteNewArtical)
  60.     timer.start()
  62. if __name__ == \'__main__\':
  63.     test()

 

版权声明：本文为leijiangtao原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/leijiangtao/p/11812747.html