python 事件驱动模型_Python学习第53天（事件驱动模型）

今天的主要内容是事件驱动模型和IO模型的一些前序知识，可能主要是文字，写的好枯燥，没有代码果然心里慌，所以自己复习了一下之前用re模块写的计算器。

昨天学习了协程，留下了一个问题，当我们遇到io操作的时候会切换进程，但是什么时候切换回来呢，这是一个问题。。。

传统的编程是如下线性模式的：

开始--->代码块A--->代码块B--->代码块C--->代码块D--->......--->结束

每一个代码块里是完成各种各样事情的代码，但编程者知道代码块A,B,C,D...的执行顺序，唯一能够改变这个流程的是数据。输入不同的数据，根据条件语句判断，流程或许就改为A--->C--->E...--->结束。每一次程序运行顺序或许都不同，但它的控制流程是由输入数据和你编写的程序决定的。如果你知道这个程序当前的运行状态(包括输入数据和程序本身)，那你就知道接下来甚至一直到结束它的运行流程。

类似于之前我们做过的计算器，按照固定的顺序或者流程进行计算。

importredefhefa(test):

l_kuohao= re.findall('\(',test)#print(len(l_kuohao))

r_kuohao = re.findall('\)',test)#print(len(r_kuohao))

zimu = re.findall('[a-z\|A-Z]+',test)#print(len(zimu))

xiaoshudian = re.findall(r'\.\.',test)#print(len(xiaoshudian))

if len(l_kuohao) ==len(r_kuohao) and len(zimu) == 0 and len(xiaoshudian) ==0:returnTrueelse:returnFalsedefinput_1():whileTrue:

test= input('请输入计算内容>>>')if hefa(test) ==True:break

else:print('请重新输入')returntestdefcheng(test):

test= test.replace('--','+')

test= test.replace('+-','-')

test= test.replace(' ', '')whileTrue:if len(re.findall('[*/]',test)) !=0 :

test_chchu= re.search('-?\d+\.?\d*[*/]-?\d+\.?\d*',test).group()if len(re.split('\*',test_chchu)) == 2:

test_ji=float(re.split('\*',test_chchu)[0].strip()) * float(re.split('\*',test_chchu)[1].strip())

test=test.replace(test_chchu,str(test_ji))else:

test_chu= float(re.split('\/',test_chchu)[0].strip()) / float(re.split('\/',test_chchu)[1].strip())

test=re.sub(test_chchu,str(test_chu),test)else:break

returntestdefadd_(test):

test= test.replace('--','+')

test= test.replace('+-','-')

test= test.replace(' ','')

test_list= re.findall('-?\d+\.?\d*',test)

a=0for i intest_list:

a+=float(i)

test=str(a)defkuohao(test):#print(type(test),test)

test_old = re.search('\([^()]*\)',test).group()#print(type(test_old),test_old)

test_old_lone = test_old.replace('(', '')#print(test_old_lone)

test_old_lone = test_old_lone.replace(')', '')#print(test_old_lone)

a =cheng(test_old_lone)#print(a)

test_new =add_(a)#print(type(test_new),test_new)

test =test.replace(test_old, test_new)#print(test)

returntestif __name__ == '__main__':#test = input_1()

test = '1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )'test= test.replace(' ','')print(test)whileTrue:if len(re.findall('\(',test)) !=0 :

test=kuohao(test)print(test)else:breaka=cheng(test)#print(type(a),a)

test_new =add_(a)print(type(test_new),test_new)print(eval('1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )'))if test_new ==eval(test):print(test_new)

对于事件驱动型程序模型，它的流程大致如下：

开始--->初始化--->等待

与上面传统编程模式不同，事件驱动程序在启动之后，就在那等待，等待什么呢？等待被事件触发。传统编程下也有“等待”的时候，比如在代码块D中，你定义了一个input()，需要用户输入数据。但这与下面的等待不同，传统编程的“等待”，比如input()，你作为程序编写者是知道或者强制用户输入某个东西的，或许是数字，或许是文件名称，如果用户输入错误，你还需要提醒他，并请他重新输入。事件驱动程序的等待则是完全不知道，也不强制用户输入或者干什么。只要某一事件发生，那程序就会做出相应的“反应”。这些事件包括：输入信息、鼠标、敲击键盘上某个键还有系统内部定时器触发。

一、事件驱动模型的介绍

通常，我们写服务器处理模型的程序时，有以下几种模型：

(1)每收到一个请求，创建一个新的进程，来处理该请求；

(2)每收到一个请求，创建一个新的线程，来处理该请；

(3)每收到一个请求，放入一个事件列表，让主进程通过非阻塞I/O方式来处理请求

第三种就是协程、事件驱动的方式，一般普遍认为第(3)种方式是大多数网络服务器采用的方式

论事件驱动模型

Title

点我呀

alert('约吗?')

}

事件驱动之鼠标点击事件注册

在UI编程中，常常要对鼠标点击进行相应，首先如何获得鼠标点击呢？ 两种方式：

1、创建一个线程循环检测是否有鼠标点击

那么这个方式有以下几个缺点：

1.CPU资源浪费，可能鼠标点击的频率非常小，但是扫描线程还是会一直循环检测，这会造成很多的CPU资源浪费；如果扫描鼠标点击的接口是阻塞的呢？

2.如果是堵塞的，又会出现下面这样的问题，如果我们不但要扫描鼠标点击，还要扫描键盘是否按下，由于扫描鼠标时被堵塞了，那么可能永远不会去扫描键盘；

3.如果一个循环需要扫描的设备非常多，这又会引来响应时间的问题；

所以，该方式是非常不好的。

2、就是事件驱动模型

目前大部分的UI编程都是事件驱动模型，如很多UI平台都会提供onClick()事件，这个事件就代表鼠标按下事件。事件驱动模型大体思路如下：

1.有一个事件(消息)队列；

2.鼠标按下时，往这个队列中增加一个点击事件(消息)；

3.有个循环，不断从队列取出事件，根据不同的事件，调用不同的函数，如onClick()、onKeyDown()等；

4.事件(消息)一般都各自保存各自的处理函数指针，这样，每个消息都有独立的处理函数；

事件驱动编程是一种编程范式，这里程序的执行流由外部事件来决定。它的特点是包含一个事件循环，当外部事件发生时使用回调机制来触发相应的处理。另外两种常见的编程范式是(单线程)同步以及多线程编程。

让我们用例子来比较和对比一下单线程、多线程以及事件驱动编程模型。下图展示了随着时间的推移，这三种模式下程序所做的工作。这个程序有3个任务需要完成，每个任务都在等待I/O操作时阻塞自身。阻塞在I/O操作上所花费的时间已经用灰色框标示出来了。

最初的问题：怎么确定IO操作完了切回去呢？通过回调函数

1.要理解事件驱动和程序，就需要与非事件驱动的程序进行比较。实际上，现代的程序大多是事件驱动的，比如多线程的程序，肯定是事件驱动的。早期则存在许多非事件驱动的程序，这样的程序，在需要等待某个条件触发时，会不断地检查这个条件，直到条件满足，这是很浪费cpu时间的。而事件驱动的程序，则有机会释放cpu从而进入睡眠态(注意是有机会，当然程序也可自行决定不释放cpu)，当事件触发时被操作系统唤醒，这样就能更加有效地使用cpu.

2.再说什么是事件驱动的程序。一个典型的事件驱动的程序，就是一个死循环，并以一个线程的形式存在，这个死循环包括两个部分，第一个部分是按照一定的条件接收并选择一个要处理的事件，第二个部分就是事件的处理过程。程序的执行过程就是选择事件和处理事件，而当没有任何事件触发时，程序会因查询事件队列失败而进入睡眠状态，从而释放cpu。

3.事件驱动的程序，必定会直接或者间接拥有一个事件队列，用于存储未能及时处理的事件。

4.事件驱动的程序的行为，完全受外部输入的事件控制，所以，事件驱动的系统中，存在大量这种程序，并以事件作为主要的通信方式。

5.事件驱动的程序，还有一个最大的好处，就是可以按照一定的顺序处理队列中的事件，而这个顺序则是由事件的触发顺序决定的，这一特性往往被用于保证某些过程的原子化。

6.目前windows,linux,nucleus,vxworks都是事件驱动的，只有一些单片机可能是非事件驱动的。

二、IO模型的前部准备

在进行解释之前，首先要说明几个概念：

用户空间和内核空间

进程切换

进程的阻塞

文件描述符

缓存 I/O

用户空间与内核空间

现在操作系统都是采用虚拟存储器，那么对32位操作系统而言，它的寻址空间(虚拟存储空间)为4G(2的32次方)。

操作系统的核心是内核，独立于普通的应用程序，可以访问受保护的内存空间，也有访问底层硬件设备的所有权限。

为了保证用户进程不能直接操作内核(kernel)，保证内核的安全，操心系统将虚拟空间划分为两部分，一部分为内核空间，一部分为用户空间。

针对linux操作系统而言，将最高的1G字节(从虚拟地址0xC0000000到0xFFFFFFFF)，供内核使用，称为内核空间，而将较低的3G字节(从虚拟地址0x00000000到0xBFFFFFFF)，供各个进程使用，称为用户空间。

进程切换

为了控制进程的执行，内核必须有能力挂起正在CPU上运行的进程，并恢复以前挂起的某个进程的执行。这种行为被称为进程切换，这种切换是由操作系统来完成的。因此可以说，任何进程都是在操作系统内核的支持下运行的，是与内核紧密相关的。

从一个进程的运行转到另一个进程上运行，这个过程中经过下面这些变化：

保存处理机上下文，包括程序计数器和其他寄存器。

更新PCB信息。

把进程的PCB移入相应的队列，如就绪、在某事件阻塞等队列。

选择另一个进程执行，并更新其PCB。

更新内存管理的数据结构。

恢复处理机上下文。

注：总而言之就是很耗资源的

进程的阻塞

正在执行的进程，由于期待的某些事件未发生，如请求系统资源失败、等待某种操作的完成、新数据尚未到达或无新工作做等，则由系统自动执行阻塞原语(Block)，使自己由运行状态变为阻塞状态。可见，进程的阻塞是进程自身的一种主动行为，也因此只有处于运行态的进程(获得CPU)，才可能将其转为阻塞状态。当进程进入阻塞状态，是不占用CPU资源的。

文件描述符fd

这部分还没讲

缓存 I/O

缓存 I/O 又被称作标准 I/O，大多数文件系统的默认 I/O 操作都是缓存 I/O。在 Linux 的缓存 I/O 机制中，操作系统会将 I/O 的数据缓存在文件系统的页缓存( page cache )中，也就是说，数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。用户空间没法直接访问内核空间的，内核态到用户态的数据拷贝

思考：为什么数据一定要先到内核区，直接到用户内存不是更直接吗？

缓存 I/O 的缺点：

数据在传输过程中需要在应用程序地址空间和内核进行多次数据拷贝操作，这些数据拷贝操作所带来的 CPU 以及内存开销是非常大的。

今天就是这些，明天会有很重要的谈话，所以今天决定早点睡，顺便看看老婆大人回家了没有。