Python/ selectors模块及队列

Python/selectors模块及队列

selectors模块是可以实现IO多路复用机制：

它具有根据平台选出最佳的IO多路机制，比如在win的系统上他默认的是select模式而在linux上它默认的epoll。

常用共分为三种：

select、poll、epoll

select的缺点：

1、每次调用都要将所有的文件描述符（fd）拷贝的内核空间，导致效率下降

2、遍历所有的文件描述符（fd）查看是否有数据访问

3、最大链接数限额（1024）

poll：

它就是select和epoll的过渡阶段，它没有最大链接数的限额

epoll：

1、第一个函数是创建一个epoll句柄，将所有的描述符（fd）拷贝到内核空间，但只拷贝一次。

2、回调函数，某一个函数或某一个动作成功完成之后会触发的函数为所有的描述符（fd）绑定一个回调函数，一旦有数据访问就是触发该回调函数，回调函数将（fd）放到链表中

3、函数判断链表是否为空

4、最大启动项没有限额

selsect实例：

 服务端
 import selectors  #基于select模块实现的IO多路复用，建议大家使用
 import socket
 sock=socket.socket()
 sock.bind(('127.0.0.1',8800))
 sock.listen(5)
 sock.setblocking(False)
 sel=selectors.DefaultSelector() #根据平台选择最佳的IO多路机制，比如linux就会选择epoll

 def read(conn,mask):
     try:
         data=conn.recv(1024)
         print(data.decode('utf8'))
         data2=input('>>>>')
         conn.send(data2.encode('utf8'))
     except Exception:
         sel.unregister(conn)

 def accept(sock,mask):
     conn,addr=sock.accept()
     print('-------',conn)
     sel.register(conn,selectors.EVENT_READ,read)
 sel.register(sock, selectors.EVENT_READ, accept)  #注册功能
 while True:
     print('wating....')
     events=sel.select()   #[(sock)，（），（）]   监听

     for key,mask in events:
         # print(key.data)       #accept   找出有活动的绑定函数
         # print(key.fileobj)    #sock     找出有活动的文件描述符

         func=key.data
         obj=key.fileobj

         func(obj,mask)  #1 accept(sock,mask) 2read(conn,mask)
 ------------------------------------------------------------------------------
 客户端
 import socket
 tin=socket.socket()
 tin.connect(('127.0.0.1',8800))
 while True:
     inp=input('>>>>')
     tin.send(inp.encode('utf8'))
     data=tin.recv(1024)
     print(data.decode('utf8'))

队列：

队列分为（先进先出、后进先出）

队列是一个数据类型，可以进行数据储存功能

队列可以实现耦合的效果，比如有个人A把包子放到锅里，在有个人B把包子从锅里拿出来。现在的锅就是队列的效果。

实例如下：

 import queue
 q=queue.Queue()  #默认的先进先出
 q.put(111)       #往管道里放一个值
 q.put(222)       #往管道里放一个值
 q.put(333)       #往管道里放一个值

 print(q.get())   #从管道里拿一个值
 print(q.get())   #从管道里拿一个值
 print(q.get())   #从管道里拿一个值
 -----------------------------------------------
 运行结果
 111
 222
 333

join和tast_done

 import queue
 q=queue.Queue()  #默认的先进先出
 q.put(111)       #往管道里放一个值
 q.task_done()    #解除阻塞
 q.put(222)       #往管道里放一个值
 q.task_done()    #解除阻塞
 q.put(333)       #往管道里放一个值
 q.task_done()    #解除阻塞
 q.join()         #队列阻塞功能
 print(q.get())   #从管道里拿一个值
 print(q.get())   #从管道里拿一个值
 print(q.get())   #从管道里拿一个值

join和tast_done 功能

如果有俩个put功能，在get的前边有join功能的话，在俩个put的后边要进行一个task_done才能执行。

生产者消费者模型：

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

这就像，在餐厅，厨师做好菜，不需要直接和客户交流，而是交给前台，而客户去饭菜也不需要不找厨师，直接去前台领取即可，这也是一个结耦的过程。

 import time,random
 import queue,threading

 q = queue.Queue()

 def Producer(name):
   count = 0
   while count <10:
     print("making........")
     time.sleep(random.randrange(3))
     q.put(count)
     print('Producer %s has produced %s baozi..' %(name, count))
     count +=1
     #q.task_done()
     #q.join()
     print("ok......")
 def Consumer(name):
   count = 0
   while count <10:
     time.sleep(random.randrange(4))
     if not q.empty():
         data = q.get()
         #q.task_done()
         #q.join()
         print(data)
         print('\033[32;1mConsumer %s has eat %s baozi...\033[0m' %(name, data))
     else:
         print("-----no baozi anymore----")
     count +=1

 p1 = threading.Thread(target=Producer, args=('A',))
 c1 = threading.Thread(target=Consumer, args=('B',))
 # c2 = threading.Thread(target=Consumer, args=('C',))
 # c3 = threading.Thread(target=Consumer, args=('D',))
 p1.start()
 c1.start()
 # c2.start()
 # c3.start()

这个生产消费者就是通过列表的形式把输入和获取进行耦合操作！