事件驱动模型与IO模型

事件驱动模型

 

 

事件驱动编程，是一种编程范式。这里程序的执行流由外部事件来决定。它的特点是包含一个循环，当外部事件发生时，使用回调机制来触发相应的处理。

另外2种常见的编程范式是（单线程）同步以及多线程编程

IO模型

 

 同步IO(synchronous)，异步IO(asynchronous)，阻塞IO(blocking) 和非阻塞IO(non-blocking) 都是独立的，不一起出现

5种IO模型如下：

-blocking IO 

-nonblocking IO

-IO multiplexing（IO多路复用）

-signal driven IO

-asynchronous IO

blocking IO (阻塞IO)

在linux 中，默认情况下所有的socket 都是blocking IO,阻塞IO 只发生了一次系统调用，进程进入阻塞状态时，是不占用CPU的。

 实例：

-server 端

import socket

sk=socket.socket()

sk.bind(("127.0.0.1",8080))

sk.listen(5)

while 1:
    conn,addr=sk.accept()

    while 1:
        conn.send("hello client".encode("utf8"))
        data=conn.recv(1024)
        print(data.decode("utf8"))

-client端

import socket

sk=socket.socket()

sk.connect(("127.0.0.1",8080))

while 1:
    data=sk.recv(1024)
    print(data.decode("utf8"))
    sk.send(b"hello server")

非阻塞IO

缺点：不能及时收发消息，系统调用太多次

 实例

-server 端

import time
import socket
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sk.bind(('127.0.0.1',6667))
sk.listen(5)
sk.setblocking(False) #此代码代表不会一值等待连接（如上图）/非阻塞
print ('waiting client connection .......')
while True:
    try:

        connection,address = sk.accept()   # 进程主动轮询
        print("+++",address)
        client_messge = connection.recv(1024)
        print(str(client_messge,'utf8'))
        connection.close()
    except Exception as e:
        print (e)
        time.sleep(4)

-client 端

import time
import socket
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

while True:
    sk.connect(('127.0.0.1',6667))
    print("hello")
    sk.sendall(bytes("hello","utf8"))
    time.sleep(2)
    break

IO multiplexing（IO多路复用）

 

IO多路复用实现并发的方法：

1）select  可跨平台使用，但是监听连接数最大为1024

2)  poll     

3) epoll （推荐使用）：效率高，最好的实现方式

 实例一：

-server 端

import socket
import select
sk=socket.socket()
sk.bind(("127.0.0.1",9904))
sk.listen(5)
inp=[sk,]
while True:

    r,w,e=select.select(inp,[],[],5) #[sk,conn] #select监听。
#inp是指输入内容，第一个[]是输出，第二个[]是报错，数字5是每隔5秒监听一次（可自己设置秒数）
#此处的r 相当于是谁变动r就等于谁。

    for i in r:#[sk,]
        conn,add=i.accept()
        print(conn)
        print("hello")
        inp.append(conn)
    print('>>>>>>')

-client 端

import socket

sk=socket.socket()

sk.connect(("127.0.0.1",9904))

while 1:
    inp=input(">>").strip()
    sk.send(inp.encode("utf8"))
    data=sk.recv(1024)
    print(data.decode("utf8"))

实例二：

server 端

import socket
import select
sk=socket.socket()
sk.bind(("127.0.0.1",8801))
sk.listen(5)
inputs=[sk,]
while True:
    r,w,e=select.select(inputs,[],[],5)#此处的r 相当于是谁变动，r等于谁

    for obj in r:#[sk,]
        if obj==sk:
            conn,add=obj.accept()#此处相当于取出sk,已监听sk.
            print(conn)
            inputs.append(conn)
        else:
            data_byte=obj.recv(1024)
            print(str(data_byte,'utf8'))
            inp=input('回答%s号客户>>>'%inputs.index(obj))
            obj.sendall(bytes(inp,'utf8'))

    print('>>',r)

当客户端与服务端连接上的时候 :inputs= [sk,] select 可以捕捉到sk变动，监听sk,执行obj ==sk 条件下代码，将conn 加入到inputs中，所以此时inputs = [sk,conn,] 此时监听sk和 conn.

但是当发消息时，因为只有conn变动，所以运行的是else下代码

client 端

import socket

sk = socket.socket()
sk.connect(('127.0.0.1', 8801))

while True:
    inp = input(">>>>")
    sk.sendall(bytes(inp, "utf8"))
    data = sk.recv(1024)
    print(str(data, 'utf8'))

python 封装的实现IO多复路模型的模块-selectors

 

 

服务端代码如下：

import selectors
import socket
sel = selectors.DefaultSelector() #创建selector 对象

def accept(sock,mask):
    conn,addr = sock.accept()
    print('accepted', conn, 'from', addr)
    conn.setblocking(False)#设置非阻塞，代码代表不会一直等待
    sel.register(conn,selectors.EVENT_READ,read)
   #将conn 与read函数绑在一起，并将conn 加入sel.select()列表中

def read(conn,mask):
    try:
        data = conn.recv(1000)
        if not data:
            raise Exception
        print('echoing', data.decode('utf-8'), 'to', conn)
        conn.send(data)
    except Exception as e:#一旦断开连接，会执行以下代码
        print('closing', conn)
        sel.unregister(conn)
        #此代码代表解绑conn,意味着sel.select()列表中不在有它
        conn.close()

sock = socket.socket()
sock.bind(("192.168.1.5",8082))
sock.listen(1000)
sock.setblocking(False)#设置socket 非阻塞，代码代表不会一直等待
sel.register(sock, selectors.EVENT_READ, accept)
#将socket 与accept函数绑在一起,并将sock 加入sel.select()列表中
print("server.....")

#当与客户端连接上时，sock有变化，events = [sock,],callback =sock=accept,accept(),accept执行,代码如下。

此时已经监听了活动socket，而accept()函数执行又将conn加入events中进行监听。
#当发送消息时，conn 有变化，所以此时的events = [conn,],callback = conn =read,read()执行，代码同样如下。

while True:
    events =sel.select()#此处events相当于是变动的监听对象，谁变动，此处就是谁
    for key, mask in events:
        callback = key.data
         #当与客户端连接上时，第一次运行时此处相当于callback=accept
　　　　　 #发送消息时，callback = read

        callback(key.fileobj, mask)
        #第一次与客户端连接时，此处相当于accept(sock,mask)，运行accept 函数。
　　　　　#发消息时，此处=read(conn,mask)

客户端

import socket

sk=socket.socket()

sk.connect(("192.168.1.5",8082))
while 1:
    inp = input(">>>>").strip()
    sk.send(inp.encode('utf-8'))
    data = sk.recv(1024)
    print(data.decode('utf-8'))

 

 

异步IO(asynchronous IO)

异步IO：全程无阻塞

 以下是这几种IO模型的区别图：

 

作业：用selectors 实现文件的上传与下载并发。 

 客户端：

import  socket
import sys,os
Base_DIR = os.path.basename(os.path.abspath(__file__))

class selectFtClient:
    def __init__(self):
        self.args = sys.argv  # sys.argv 相当于系统从外部获取数据,以列表形式存放[代码本身文件路径,输入内容]
        if len(self.args) > 1:
            self.port = (self.args[1], int(self.args[2]))
        else:
            self.port = ('192.168.1.4', 8080)
        self.creat_socket()
        self.command_fanout()

    def creat_socket(self):
        try:
            self.sk = socket.socket()
            self.sk.connect(self.port)
            print('连接服务器成功')
        except Exception as e:
            print("error",e)

    def command_fanout(self):
        while True:
            cmd = input('>>>').strip()
            if not cmd: #代表输入为空
                break
            cmd,file = cmd.split()
            if hasattr(self,cmd):#判断是否有cmd方法
                func = getattr(self,cmd)
                func(cmd,file)
            else:
                print('调用错误！')
    def put(self,cmd,file):
        if os.path.isfile(file):
            fileName = os.path.basename(file)
            fileSize = os.path.getsize(file)
            fileInfo = "%s|%s|%s"%(cmd,fileName,fileSize)
            self.sk.send(fileInfo.encode('utf8'))
            recvStatus = self.sk.recv(1024)
            print('recvStatus',recvStatus)
            hasSend = 0
            if recvStatus.decode('utf8')=="ok":
                with open(file,'rb') as f:
                    while fileSize > hasSend:
                        contant = f.read(1024)
                        recv_size = len(contant)
                        self.sk.send(contant)
                        hasSend +=recv_size
                        s= str(int(hasSend/fileSize*100))+"%"
                        print('正在上传文件：%s，已上传：%s'%(fileName,s))
                print('%s上传完毕'%fileName)
        else:
            print('文件不存在')

    def get(self,cmd,file):
        pass


if __name__ == "__main__":
    selectFtClient()

服务端：

import os
import sys
import time
BASE_DIR = os.path.dirname(os.path.abspath(__file__))#upload项
import socket
import selectors


class selectFtpServer:
    def __init__(self):
        self.dic = {}
        self.sel = selectors.DefaultSelector() #创建selectors对象
        self.creat_socket()
        self.handle()


    def creat_socket(self):
        server = socket.socket()#创建socket
        server.bind(('192.168.1.4',8080))#绑定端口
        server.listen(5)#监听
        server.setblocking(False)#设置不阻塞
        self.sel.register(server,selectors.EVENT_READ,self.accept)
        print('服务端已开启，等待用户连接....')

    def handle(self):
        while True:
            events = self.sel.select()#监听有变化的
            for key,mask in events:
                callback =key.data
                callback(key.fileobj,mask)

    def accept(self,sock,mask):
        conn,addr = sock.accept
        print('connected conn: %s '%conn)
        print('connected addr: %s '%addr)
        conn.setblocking(False)
        self.sel.register(conn,selectors.EVENT_READ,self.read)
        self.dic[conn]={}
    def read(self,conn,mask):
        if not self.dic[conn]:
            data = conn.recv(1024)
            cmd, filename, filesize = data.decode('utf8').split('|')
            self.dic = {conn: {'cmd': cmd, 'filename': filename, 'filesize': int(filesize)}}

            if cmd == 'put':
                conn.send("ok".encode('utf8'))
            if self.dic[conn]['cmd'] == 'get':
                file = os.path.join(BASE_DIR, 'download', filename)
                if os.path.exists(file):
                    fileSize = os.path.getsize(file)
                    send_info = "%s|%s" % ('yes',fileSize)
                    conn.send(send_info.encode('utf8'))
                else:
                    send_info = '%s|%s'%('no',0)
                    conn.send(send_info.encode('utf8'))
        else:
            if self.dic[conn].get('cmd', None):
                cmd = self.dic[conn].get('cmd')
                if hasattr(self, cmd):
                    func = getattr(self, cmd)
                    func(conn)
                else:
                    print('error cmd !')
                    conn.close()
            else:
                print('error cmd !')


    def put(self,conn):

        fileName = self.dic[conn]['fileName']
        fileSize = self.dic[conn]['fileSize']
        path = os.path.join(BASE_DIR,'upload',fileName)
        recv_data = conn.recv(1024)
        self.hasRecv +=len(recv_data)

        with open(path,'ab') as f:
            f.write(recv_data)
        if fileSize ==self.hasRecv:
            if conn in self.dic.keys():
                self.dic[conn]={}
            print('%s上传完毕！'%fileName)


if __name__ == "__main__":
    selectFtpServer()