#!/usr/bin/env python3
# -*- coding:utf-8 -*-

import socket
server = socket.socket(family=socket.AF_INET,type=socket.SOCK_STREAM)

server.bind(("127.0.0.1",6666)) 

server.listen(5)

while 1:
    conn,client_addr = server.accept()   阻塞点 1
    :
        try: 
            data = conn.recv(1024)   阻塞点 2
            if not data:
                break
            conn.send(data.upper())
        except ConnectionResetError as e:
            print(client_addr,关闭了双向链接")
            
    conn.close()

socket.SOCK_STREAM)

server.setblocking(False)   设置为非阻塞

server.bind(())

server.listen(5:
    :
        conn,1)"> 不阻塞
    except BlockingIOError as e:   捕捉异常
        continue

    :
            data = conn.recv(1024)   读取数据时依然会阻塞
            break
         捕捉异常
            continue

    conn.close()

 socket
 select

server = socket.socket(family=socket.AF_INET,1)">)

r_list = [server,]   被监听的socket对象，读取事件
w_list = []   被监听的socket对象，写入事件

:
    r,w,e = select.select(r_list,w_list,[],0.5)

    """
    r:   相当于一个空列表，当被监听的r_list中有任何对象能够读取数据了，则放到 r 列表中。
    w:   同上，放的是可写的
    e：   同上，放的是错误的
    0.5:  循环监听的时间，每隔多少秒监听一次
    """

    for i in r:   当有任何可读就执行这里，这个就是事件循环。阻塞点 1
        print(-----,r)
        if i == server:
            conn,addr = i.accept()
            r_list.append(conn)   将链接通道 conn 放入监听队列
        else:   如果不是server端，那就是conn，链接通道
            :
                data = i.recv(1024)   阻塞点2
                not data: 
                i.send(data.upper())
             ConnectionResetError:
                断开链接通道 将conn从可读列表中移除

    
    1.开启服务端，监听可读事件列表 r_list,r_list = [socket对象,]  现在的r = []
    2.开启客户端，发送请求链接，r 列表新增了一个可读  r = [socket对象] ，执行for循环，条件成立
    3.建立双向链接通道，将链接通道放入可读事件列表 r_list = [socket对象，conn1]

    # --- 客户端给服务端发消息 ---

    1.此时的被监听列表 r_list = [socket对象，conn1]
    2.客户端发了一个消息， r_list = [conn1,]
    3. 执行for循环，条件不成立

    # --- 客户端断开链接 ---

    1.从监听列表 r_list 中删除了 conn1

    """

 selectors

sel = selectors.DefaultSelector()   自动选择，select，poll，epoll


def accept(sock,mask):
    conn,client_addr = sock.accept()   拿到双向链接
    新的双向链接通道{0}来自{1}.format(conn,client_addr))
    sel.register(conn,selectors.EVENT_READ,read)   为conn注册可读事件，绑定回调函数read


 read(conn,mask):
    try:   <--针对 windows 平台客户端强制退出服务端会抛出异常
        data = conn.recv(1024)
        not data:   <-- 针对 UNIX 平台客户端强制退出服务端会无限收空
            close_conn(conn,mask)
        conn.send(data.upper())
     ConnectionResetError as e:
        close_conn(conn,mask)


 close_conn(conn,mask):
    sel.unregister(conn)   注销对conn双向链接通道的监听
     socket.socket()
server.bind(())
server.listen(5)
server.setblocking(False)   设置非阻塞

sel.register(server,accept)   为server注册可读事件，回调函数为accept

 run():
    while 1:   只要有注册的事件触发了，就会执行相应的回调函数，这里是死循环不断检测
        events = sel.select(5)   最大监听时间
        for key,mask in events:
            callback = key.data   key.data 就是回调函数
            callback(key.fileobj,mask)   执行回调，key.fileobj是监听的对象，也就是注册时的对象。

if __name__ == '__main__':
    run()

from concurrent.futures  ThreadPoolExecutor
     events:
            with ThreadPoolExecutor(5) as pool:
                callback = key.data   key.data 就是回调函数
                pool.submit(callback,key.fileobj,1)"> 执行回调，key.fileobj是监听的对象，也就是注册时的对象。

 greenlet

 f1():
    print(1)
    gr2.switch()  执行协程2
    print(2)
    gr2.switch()

 f2():
    print(3)
    gr1.switch()
    print(4 表示创建了2个协程。由1个线程创建出来的

gr1 = greenlet.greenlet(f1)  
gr2 = greenlet.greenlet(f2)

gr1.switch()   执行协程1
 ==== 执行结果 ====

1
3
2
4
"""

 gevent
from gevent  monkey
monkey.patch_all()   对以下代码中有IO操作就切换
 requests

 f(url):
    res = requests.get(url)   碰见 I/O 自动切换自另一个协程
    print(url,res.text)

gevent.joinall([
    gevent.spawn(f,https://www.baidu.com/"), 协程 1
    gevent.spawn(f,1)">https://www.yahoo.com/ 协程 2
]
)