>>> import socket
>>> server = socket.socket()
# 讲socket设置成非阻塞
>>> server.setblocking(False)   # 注意！这必须要在其他操作之前！
>>> server.bind((‘‘,8080))
>>> server.listen(5)
?
>>> server.accept()     # 没有连接就引发BlockingIOError
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    server.accept()
  File "E:\python\lib\socket.py", line 205, in accept
    fd, addr = self._accept()
BlockingIOError: [WinError 10035] 无法立即完成一个非阻止性套接字操作。
?
# 使用一个客户端（普通的就行，不需要非阻塞）连接过来
>>> conn,addr = server.accept()     # 有连接则正确返回
>>> conn.recv(1024)     # 没有连接数据就引发BlockingIOError
Traceback (most recent call last):
  File "<pyshell#9>", line 1, in <module>
    conn.recv(1024)
BlockingIOError: [WinError 10035] 无法立即完成一个非阻止性套接字操作。

# 原来的recv
while True:
    try:
        recv_data = conn.recv(1024)
        break
    except BlockingIOError:
        pass
        
# 原来的accept
while True:
    try:
        conn,addr = server.accept()
        break
    except:BlockingIOError:
        pass

import socket
server = socket.socket()        # 生成套接字
server.setblocking(False)       # 非阻塞
server.bind((‘‘,7788))
server.listen(1000)
?
# 我们现在生成的非阻塞套接字，非阻塞套接字在执行accept跟recv的时候不会阻塞，但是会报错，
# 所以我们写非阻塞的并发服务器需要用到异常处理
?
all_conn = []   # 用来保存我们所有的已经生成的套接字(这个客户端还在连接着)
while True:
    # 处理连接，生成对等连接套接字
    try:
        conn,addr = server.accept()
        conn.setblocking(False)     # conn是新生成的，需要给它设置一下非阻塞
        all_conn.append(conn)   # 这一行代码的前提是，上面一行代码正常返回
    except BlockingIOError:
        pass
    for conn in all_conn:
        try:    # 只负责接受数据
            recv_data = conn.recv(1024)
?
            if recv_data:
                res = recv_data.decode()
                print(res)
                conn.send(recv_data)
            else:
                conn.close()
                all_conn.remove(conn) # 客户端关闭连接，就把它移除
        except BlockingIOError:
            pass

>>> import socket
>>> import selectors
>>> server = socket.socket()
>>> server.bind((‘‘,9000))
>>> server.listen(1000)
>>> selector = selectors.EpollSelector()    # 实例化一个 epoll 选择器
>>> def create_conn(server):
...     conn,addr = server.accept()
...     return conn
... 
# 套接字、事件、回调函数
>>> selector.register(server,selectors.EVENT_READ,create_conn)  
SelectorKey(fileobj=<socket.socket fd=3,    # 生成一个打包对象
family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=(‘0.0.0.0‘, 9000)>,   # fileobj是对应套接字
fd=3,
events=1,   # 事件（1 表示EVENT_READ）
data=<function create_conn at 0xb70b7b24>)  # data是对应的回掉函数

events = selector.select()      # 查询，返回所有已经准备好的资源打包对象
print(enents)       # 是一个 ‘二元组’ 的列表
[(SelectorKey(fileobj=<socket.socket fd=4, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=(‘0.0.0.0‘, 8888)>, fd=4, events=1, data=<function accept at 0xb71f292c>), 1)]
# 我们只需要关心，每个元祖的第一项（即打包对象，其中包含了对应的套接字与回掉函数）
# 接下来并不需要关心是什么套接字，什么事件，只需要调用对应的对调函数即可
callbeck = events[0][0].data
sock = events[0][0].fileojb
callbeck(sock)

# 使用EpollSelector，实现一个并发的服务器
import socket
import selectors    # IO多路复用选择器的模块，接口，调用epoll
?
epoll_selector = selectors.EpollSelector()  # 创建一个用来和epoll通信的选择器
?
server = socket.socket()
server.bind((‘‘,8888))
server.listen(1000)
?
def read(conn):
    recv_data = conn.recv(1024)
    if recv_data:
        print(recv_data.decode())
        conn.send(recv_data)
    else:
        epoll_selector.unregister(conn)     # 现在数据已经传输完了，那我现在就不用再去监控它了，所以# 关闭监控
        conn.close()    # 关闭连接
?
def accept(server):
    conn, addr = server.accept()    # 生成一个对等连接套接字
    # 要准备接受数据
    epoll_selector.register(conn, selectors.EVENT_READ, read)
?
epoll_selector.register(server,selectors.EVENT_READ, accept)   # 注册事件在可以读的时候的回调函数
?
# 事件循环(主动去问epoll，哪些socket可以回调了，如果有了，那我就回调)
while True:
    events = epoll_selector.select()     # 查询所有的已经准备好的事件，返回一个列表(二元组列表)
    # a, b = events
    for key, mask in events:    # 第一项是我们需要用的
        callback = key.data    # 从key里面把回掉函数拿出来
        sock = key.fileobj     # 从key里面把我们注册的那个socket拿出来
        callback(sock)