第五十五节，IO多路复用select模块加socket模块，伪多线并发

IO多路复用select模块加socket模块，伪多线并发，并非真正的多线程并发，实际经过循环等待仍是一个一个处理的

IO多路复用，lo就是文件或数据的输入输出，IO多路复用就是能够多用户操做

IO多路复用，能够监听多个文件描述符（socke对象）（文件句柄），一旦文件句柄出现变化，便可感知到，感知到后做出相应操做

 

好比原生socke模块只能监听一个端口和只能一个用户链接，要想实现监听多个端口和支持多用户，就会使用IO多路复用

 

IO多路复用select模块

select()自动监听socket对象的客户端，链接地址和、客户端通信地址，四个参数

select()自动监听列表里的socket对象（文件描述符），一旦监听的对象，谁发生了变化（有用户请求），
就将发生变化对象的客户端链接地址赋值给第一个变量a，第一个变量接收的列表，列表里的每个元素，就是一个端口的用户链接地址
若是是多个端口在同时链接客户端，那么列表元素就是多个元素

最多监听端口1024个

使用方法：a, b, c = select.select(列表类型的socke对象变化, [可选：传参直接赋值给第二个变量], [可选：列表类型的socke对象监听错误], 多少秒检测一次)

　　须要四个参数　

　　参数一：列表类型的socke对象，监听变化

　　参数二：传参直接赋值给第二个变量

　　参数三：列表类型的socke对象，监听错误

　　参数四：多少秒检测一次

　　须要三个变量来接收返回值

　　第一个变量接收的：列表类型客户端链接地址，若是无客户端链接则为空列表

　　第二个变量接收的：第二个参数的值

　　第三个变量接收的：第三个参数监听socke对象的错误信息,返回列表，无错误则为空列表

格式：a, b, c = select.select(lib, [], [], 1)

格式2：a, b, c = select.select(lib, k1, lib, 1)

IO多路复用多端口监听客户端链接地址、服务端代码

#!/usr/bin/env python
# -*- coding:utf8 -*-
"""服务端"""
import socket #导入模块
"""设置多个对象，绑定不一样端口"""
k1 = socket.socket() #建立对象
k1.bind(('127.0.0.1', 9991)) #绑定服务端IP和端口
k1.listen() #监听IP和端口

k2 = socket.socket() #建立对象
k2.bind(('127.0.0.1', 9992)) #绑定服务端IP和端口
k2.listen() #监听IP和端口

k3 = socket.socket() #建立对象
k3.bind(('127.0.0.1', 9993)) #绑定服务端IP和端口
k3.listen() #监听IP和端口
"""将多个对象组合成列表"""
lib = [k1, k2, k3]

"""使用自动监听模块"""
import select #导入自动监听多个端口模块
while True:
    #select()自动监听列表里的socket对象（文件描述符），一旦监听的对象，谁发生了变化（有用户请求），
    # 就将发生变化对象的客户端链接地址赋值给第一个变量a，第一个变量接收的列表，列表里的每个元素，就是一个端口的用户链接地址
    #若是是多个端口在同时链接客户端，那么列表元素就是多个元素
    a, b, c = select.select(lib, [], [], 1)
    for k in a: #循环出select()获取到的列表类型客户端链接地址
        d, e = k.accept() #将循环到的每个客户端链接地址等待通信，阻塞
        d.sendall(bytes("欢迎访问", encoding="utf-8")) #向链接的客户端发送一条消息

客户端代码1

#!/usr/bin/env python
# -*- coding:utf8 -*-
"""建立客户端"""
import socket #导入模块
z = socket.socket() #建立socket对象
b = z.connect(('127.0.0.1', 9991,))#链接服务端，在客户端绑定服务端IP和端口

f = z.recv(1024) #客户端接收服务端sendall()发来的信息，1024表示最大接收1024字节
f2 = str(f, encoding='utf-8') #将接收到的服务端字节信息转换成字符串
print(f2) #打印出服务端发来的信息

客户端代码2

#!/usr/bin/env python
# -*- coding:utf8 -*-
"""建立客户端"""
import socket #导入模块
z = socket.socket() #建立socket对象
b = z.connect(('127.0.0.1', 9992,))#链接服务端，在客户端绑定服务端IP和端口

f = z.recv(1024) #客户端接收服务端sendall()发来的信息，1024表示最大接收1024字节
f2 = str(f, encoding='utf-8') #将接收到的服务端字节信息转换成字符串
print(f2) #打印出服务端发来的信息

IO多路复用多端口监听、客户端链接地址原理图

 

IO多路复用监听客户端多通信地址

经过select()监听到客户端变化信息对象，拿到变化信息对象，判断是链接信息对象，仍是通信信息对象？若是是链接信息对象，经过变化信息对象获取到此链接的通信对象，将通信对象添加到select()里监听，若是是通信对象，经过通信对象进行信息交互

IO多路复用监听客户端多通信地址服务端代码

#!/usr/bin/env python
# -*- coding:utf8 -*-
"""服务端"""
import socket #导入模块
k1 = socket.socket() #建立对象
k1.bind(('127.0.0.1', 9991)) #绑定服务端IP和端口
k1.listen() #监听IP和端口
lib = [k1]

"""使用自动监听模块"""
import select #导入自动监听多个端口模块
while True:
    #select()自动监听列表里的socket对象（文件描述符），一旦监听的对象，谁发生了变化（有用户请求），
    # 就将发生变化对象的客户端链接地址赋值给第一个变量a，第一个变量接收的列表，列表里的每个元素，就是一个端口的用户链接地址
    #若是是多个端口在同时链接客户端，那么列表元素就是多个元素
    a, b, c = select.select(lib, [], [], 1)
    print("正在监听的socket对象 %d" % len(lib)) #监听的对象有多少个
    print(a) #监听发生变化的有哪些
    for k in a: #循环出select()获取到的列表类型客户端链接地址
        if k == k1: #判断循环到的链接地址等于socket对象，说明有新用户链接
            d, e = k.accept() #等待请求，获取客户端通信地址
            lib.append(d) #将客户端通信地址追加到列表，传入select()监听通信变化
            d.sendall(bytes("你好", encoding="utf-8"))
        else: #若是不是链接信息，说明是通信信息
            try: #监控代码是否出现异常，若是客户端关闭了就会出现异常，没出现异常执行里面的代码
                fd = k.recv(1024)
                f = str(fd, encoding="utf-8")
                g = f + "好"
                k.sendall(bytes(g, encoding="utf-8"))
            except Exception as ex: #出现异常将当前通信对象移除列表，select不在监听
                lib.remove(k)

客户端代码

#!/usr/bin/env python
# -*- coding:utf8 -*-
"""建立客户端"""
import socket #导入模块
z = socket.socket() #建立socket对象
b = z.connect(('127.0.0.1', 9991,))#链接服务端，在客户端绑定服务端IP和端口
while True:
    f = z.recv(1024) #客户端接收服务端sendall()发来的信息，1024表示最大接收1024字节
    f2 = str(f, encoding='utf-8') #将接收到的服务端字节信息转换成字符串
    print(f2) #打印出服务端发来的信息
    a = input("输入要发送的信息")
    z.sendall(bytes(a, encoding="utf-8"))

 IO多路复用监听客户端多通信原理图

 

IO多路复用,有三种方式(select)、(poll)、(epoll) select和poll其实都是调用计算机底层来实现的监听处理，epoll是异步处理的是文件描述符发生变化后主动告诉epoll的，这里咱们须要知道一下

注意：wds系统只支持select模块，

 

 

利用select()的第二个参数，实现IO多路复用，服务端读写分离
也就是读和写分开，在不一样的代码块

 

服务端读写分离代码

#!/usr/bin/env python
# -*- coding:utf8 -*-
"""服务端实现读写分离"""
import socket #导入模块
k1 = socket.socket() #建立对象
k1.bind(('127.0.0.1', 9991)) #绑定服务端IP和端口
k1.listen() #监听IP和端口

lib = [k1] #监听的客户链接地址或，客户通信地址,传给select第一个参数
lib2 = [] #接收客户端通信地址，传给select第二个参数
jilu = {} #接收字典，里面是客户端发通信内容的用户通信地址(键)和通信内容(值)

"""使用自动监听模块"""
import select #导入自动监听多个端口模块
while True:
    #select()自动监听列表里的socket对象（文件描述符），一旦监听的对象，谁发生了变化（有用户请求），
    # 就将发生变化对象的客户端链接地址赋值给第一个变量a，第一个变量接收的列表，列表里的每个元素，就是一个端口的用户链接地址
    #若是是多个端口在同时链接客户端，那么列表元素就是多个元素
    a, b, c = select.select(lib, lib2, lib, 1)
    print("正在监听的socket对象 %d" % len(lib)) #监听的对象有多少个
    print(a) #监听发生变化的有哪些
    """循环判断连接地址或通信地址，获取客户端通信信息以及内容"""
    for k in a: #循环出select()获取到的列表类型客户端链接地址
        if k == k1: #判断循环到的链接地址等于socket对象，说明有新用户链接
            d, e = k.accept() #等待请求，获取客户端通信地址
            lib.append(d) #将客户端通信地址追加到列表，传入select()监听通信变化
            jilu[d] = [] #将链接用户通信地址添加到字典为键，值为空列表
        else: #若是不是链接信息，说明是通信信息
            try: #监控代码是否异常
                fd = k.recv(1024) #获取客户端发的信息
            except Exception as e: #若是异常将此通信地址移除列表，中止监听
                lib.remove(k) #通信地址移除列表
            else:
                fd2 = str(fd, encoding="utf-8") #接收客户端发的信息转换成字符串
                jilu[k].append(fd2) # 将客户端转换的字符串追加到，字典里当前客户键的，列表里为值
                lib2.append(k) #将当前客户通信地址，添加到select第二个参数列表里
    """向客户端发信息"""
    for km in b: #循环select第二个参数列表里的通信用户
        jkd = jilu[km][0] #经过通信用户拿到字典里对应的通信内容
        del jilu[km][0] #拿到通信内容后删除通信内容
        km.sendall(bytes(jkd+"好", encoding="utf-8")) #将通信内容加个好字，在发给客户端
        lib2.remove(km ) #在通信列表移除当前通信地址

    for fh in c: #若是监听链接出现异常
        lib.remove(fh) #移除当前链接

客户端代码

 

#!/usr/bin/env python
# -*- coding:utf8 -*-
"""建立客户端"""
import socket #导入模块
z = socket.socket() #建立socket对象
b = z.connect(('127.0.0.1', 9991,))#链接服务端，在客户端绑定服务端IP和端口
while True:
    a = input("输入要发送的信息")
    z.sendall(bytes(a, encoding="utf-8"))
    f = z.recv(1024) #客户端接收服务端sendall()发来的信息，1024表示最大接收1024字节
    f2 = str(f, encoding='utf-8') #将接收到的服务端字节信息转换成字符串
    print(f2) #打印出服务端发来的信息

 IO多路复用，服务端读写分离原理图