# ========== 协程
# 协程介绍
# 协程：是单线程下的并发，又称微线程，纤程。英文名Coroutine。
# 一句话说明什么是线程：协程是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的。、
#强调的
#1. python的线程属于内核级别的，即由操作系统控制调度（如单线程遇到io或执行时间过长就会被迫交出cpu执行权限，
#切换其他线程运行）
#2. 单线程内开启协程，一旦遇到io，就会从应用程序级别（而非操作系统）控制切换，以此来提升效率
# （！！！非io操作的切换与效率无关）
#对比操作系统控制线程的切换，用户在单线程内控制协程的切换
# 优点
#1. 协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
#2. 单线程内就可以实现并发的效果，最大限度地利用cpu
#缺点
#1. 协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程
#2. 协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程
#总结协程特点：
# 1 必须在只有一个单线程里实现并发
# 2 修改共享数据不需加锁
# 3 用户程序里自己保存多个控制流的上下文栈
# 4 附加：一个协程遇到IO操作自动切换到其它协程（如何实现检测IO，yield、greenlet都无法实现，就用到了gevent模块（select机制））
## 进程 启动多个进程 进程之间是由操作系统负责调用
# 线程 启动多个线程 真正被CPU执行的最小单位实际是线程
# 开启一个线程 创建一个线程 寄存器 堆栈
# 关闭一个线程
# 协程
# 本质上是一个线程
# 能够在多个任务之间切换来节省一些IO时间
# 协程中任务之间的切换也消耗时间,但是开销要远远小于进程线程之间的切换
# 实现并发的手段
# import time
# def consumer():
# while True:
# x = yield
# time.sleep(1)
# print('处理了数据 :',x)
#
# def producer():
# c = consumer()
# next(c)
# for i in range(10):
# time.sleep(1)
# print('生产了数据 :',i)
# c.send(i)
#
# producer()
# greenlet 模块
# greenlet只是提供了一种比generator更加便捷的切换方式，
# 当切到一个任务执行时如果遇到io，那就原地阻塞，仍然是没有解决遇到IO自动切换来提升效率的问题。
# 真正的协程模块就是使用greenlet完成的切换
#g1.switch('egon')#可以在第一次switch时传入参数，以后都不需要
# from greenlet import greenlet
# def eat():
# print('eating start')
# g2.switch()
# print('eating end')
# g2.switch()
#
# def play():
# print('playing start')
# g1.switch()
# print('playing end')
# g1 = greenlet(eat)
# g2 = greenlet(play)
# g1.switch()
# from gevent import monkey;monkey.patch_all()
# import time
# import gevent
# import threading
# def eat():
# print(threading.current_thread().getName())
# print(threading.current_thread())
# print('eating start')
# time.sleep(1)
# print('eating end')
#
# def play():
# print(threading.current_thread().getName())
# print(threading.current_thread())
# print('playing start')
# time.sleep(1)
# print('playing end')
#
# g1 = gevent.spawn(eat)
# g2 = gevent.spawn(play)
# g1.join()
# g2.join()
# gevent 模块
# 进程和线程的任务切换右操作系统完成
# 协程任务之间的切换由程序(代码)完成,只有遇到协程模块能识别的IO操作的时候,程序才会进行任务切换,实现并发的效果
# 上例gevent.sleep(2)模拟的是gevent可以识别的io阻塞,而time.sleep(2)或其他的阻塞,\
# gevent是不能直接识别的需要用下面一行代码,打补丁,就可以识别了
# from gevent import monkey;monkey.patch_all()必须放到被打补丁者的前面，如time，socket模块之前
# 或者我们干脆记忆成：要用gevent，需要将from gevent import monkey;monkey.patch_all()放到文件的开头
# gevent 是一个第三方库，可以轻松通过gevent实现并发同步或异步编程，在gevent中用到的主要模式是Greenlet,
# 它是以C扩展模块形式接入Python的轻量级协程。 Greenlet全部运行在主程序操作系统进程的内部，但它们被协作式地调度。
# 方法
# g1=gevent.spawn(func,1,,2,3,x=4,y=5)创建一个协程对象g1，spawn括号内第一个参数是函数名，如eat，
# 后面可以有多个参数，可以是位置实参或关键字实参，都是传给函数eat的
# g2=gevent.spawn(func2)
#g1.join() #等待g1结束
#g2.join() #等待g2结束
#或者上述两步合作一步：gevent.joinall([g1,g2])
#g1.value#拿到func1的返回值
# 同步 和 异步
# from gevent import monkey;monkey.patch_all()
# import time
# import gevent
#
# def task(n):
# time.sleep(1)
# print(n)
#
# def sync():
# for i in range(10):
# task(i)
#
# def async():
# g_lst = []
# for i in range(10):
# g = gevent.spawn(task,i)
# g_lst.append(g)
# gevent.joinall(g_lst) # for g in g_lst:g.join()
# sync()
# async()
# 协程 : 能够在一个线程中实现并发效果的概念
# 能够规避一些任务中的IO操作
# 在任务的执行过程中,检测到IO就切换到其他任务
# 多线程 被弱化了
# 协程 在一个线程上 提高CPU 的利用率
# 协程相比于多线程的优势 切换的效率更快
# 爬虫的例子
# 请求过程中的IO等待
# from gevent import monkey;monkey.patch_all()
# import gevent
# from urllib.request import urlopen # 内置的模块
# def get_url(url):
# response = urlopen(url)
# content = response.read().decode('utf-8')
# return len(content)
#
# g1 = gevent.spawn(get_url,'http://www.baidu.com')
# g2 = gevent.spawn(get_url,'http://www.sogou.com')
# g3 = gevent.spawn(get_url,'http://www.taobao.com')
# g4 = gevent.spawn(get_url,'http://www.hao123.com')
# g5 = gevent.spawn(get_url,'http://www.cnblogs.com')
# gevent.joinall([g1,g2,g3,g4,g5])
# print(g1.value)
# print(g2.value)
# print(g3.value)
# print(g4.value)
# print(g5.value)
# ret = get_url('http://www.baidu.com')
# print(ret)
# socket server
#通过gevent实现单线程下的socket并发
#注意 ：from gevent import monkey;monkey.patch_all()一定要放到导入socket模块之前，否则gevent无法识别socket的阻塞
#server 端
# from gevent import monkey;monkey.patch_all()
# import socket
# import gevent
# def talk(conn):
# conn.send(b'hello')
# print(conn.recv(1024).decode('utf-8'))
# conn.close()
#
# sk = socket.socket()
# sk.bind(('127.0.0.1',8080))
# sk.listen()
# while True:
# conn,addr = sk.accept()
# gevent.spawn(talk,conn)
# sk.close()
#client 端
# import socket
# sk = socket.socket()
# sk.connect(('127.0.0.1',8080))
# print(sk.recv(1024))
# msg = input('>>>').encode('utf-8')
# sk.send(msg)
# sk.close()
# ===================== IO 模型
# IO模型
#阻塞 非阻塞 io多路复用
#阻塞
# 几乎所有的程序员第一次接触到的网络编程都是从listen()、send()、recv() 等接口开始的，
# 使用这些接口可以很方便的构建服务器/客户机的模型。然而大部分的socket接口都是阻塞型的
# 实际上，除非特别指定，几乎所有的IO接口 ( 包括socket接口 ) 都是阻塞型的。这给网络编程带来了一个很大的问题，
# 如在调用recv(1024)的同时，线程将被阻塞，在此期间，线程将无法执行任何运算或响应任何的网络请求。
# 非阻塞
#在非阻塞式IO中，用户进程其实是需要不断的主动询问kernel数据准备好了没有
# 所以，在非阻塞式IO中，用户进程其实是需要不断的主动询问kernel数据准备好了没有。
# 但是非阻塞IO模型绝不被推荐。
# 我们不能否则其优点：能够在等待任务完成的时间里干其他活了
# （包括提交其他任务，也就是 “后台” 可以有多个任务在“”同时“”执行）。
#但是也难掩其缺点：
#1. 循环调用recv()将大幅度推高CPU占用率；这也是我们在代码中留一句time.sleep(2)的原因,否则在低配主机下极容易出现卡机情况
#2. 任务完成的响应延迟增大了，因为每过一段时间才去轮询一次read操作，
# 而任务可能在两次轮询之间的任意时间完成。这会导致整体数据吞吐量的降低。
# 非阻塞 代码 server 端
# import socket
# sk = socket.socket()
# sk.bind(('127.0.0.1',9000))
# sk.setblocking(False)
# sk.listen()
# conn_l = []
# del_conn = []
# while True:
# try:
# conn,addr = sk.accept() #不阻塞,但是没人连我会报错
# print('建立连接了:',addr)
# conn_l.append(conn)
# except BlockingIOError:
# for con in conn_l:
# try:
# msg = con.recv(1024) # 非阻塞,如果没有数据就报错
# if msg == b'':
# del_conn.append(con)
# continue
# print(msg)
# con.send(b'byebye')
# except BlockingIOError:pass
# for con in del_conn:
# con.close()
# conn_l.remove(con)
# del_conn.clear()
# while True : 10000 500 501
# 非阻塞 client 端
# import time
# import socket
# import threading
# def func():
# sk = socket.socket()
# sk.connect(('127.0.0.1',9000))
# sk.send(b'hello')
# time.sleep(1)
# print(sk.recv(1024))
# sk.close()
# for i in range(2):
# threading.Thread(target=func).start()
# IO 模型多虑复用
# 当用户进程调用了select，那么整个进程会被block，而同时，kernel会“监视”所有select负责的socket，
# 当任何一个socket中的数据准备好了，select就会返回。这个时候用户进程再调用read操作，将数据从kernel拷贝到用户进程。
# 强调：
# 1 。如果处理的连接数不是很高的话，使用select / epoll的web
# server不一定比使用multi - threading + blockingIO的web
# server性能更好，可能延迟还更大。select / epoll的优势并不是对于单个连接能处理得更快，而是在于能处理更多的连接。
# 2 。 在多路复用模型中，对于每一个socket，一般都设置成为non - blocking，但是，如上图所示，
# 整个用户的process其实是一直被block的。只不过process是被select这个函数block，而不是被socketIO给block。
# 结论: select的优势在于可以处理多个连接，不适用于单个连接
#该模型的优点：
#相比其他模型，使用select() 的事件驱动模型只用单线程（进程）执行，占用资源少，
# 不消耗太多 CPU，同时能够为多客户端提供服务。如果试图建立一个简单的事件驱动的服务器程序，这个模型有一定的参考价值。
#该模型的缺点：
#首先select()接口并不是实现“事件驱动”的最好选择。因为当需要探测的句柄值较大时，select()接口本身需要消耗大量时间去轮询各个句柄。
#很多操作系统提供了更为高效的接口，如linux提供了epoll，BSD提供了kqueue，Solaris提供了/dev/poll，…。
#如果需要实现更高效的服务器程序，类似epoll这样的接口更被推荐。遗憾的是不同的操作系统特供的epoll接口有很大差异，
#所以使用类似于epoll的接口实现具有较好跨平台能力的服务器会比较困难。
#其次，该模型将事件探测和事件响应夹杂在一起，一旦事件响应的执行体庞大，则对整个模型是灾难性的。
# 代码 server 端
# import select
# import socket
#
# sk = socket.socket()
# sk.bind(('127.0.0.1',8000))
# sk.setblocking(False)
# sk.listen()
#
# read_lst = [sk]
# while True: # [sk,conn]
# r_lst,w_lst,x_lst = select.select(read_lst,[],[])
# for i in r_lst:
# if i is sk:
# conn,addr = i.accept()
# read_lst.append(conn)
# else:
# ret = i.recv(1024)
# if ret == b'':
# i.close()
# read_lst.remove(i)
# continue
# print(ret)
# i.send(b'goodbye!')
# client 端
# import time
# import socket
# import threading
# def func():
# sk = socket.socket()
# sk.connect(('127.0.0.1',8000))
# sk.send(b'hello')
# time.sleep(3)
# print(sk.recv(1024))
# sk.close()
#
# for i in range(20):
# threading.Thread(target=func).start()
# 异步IO(Asynchronous I/O)
#Linux下的asynchronous IO其实用得不多
# 用户进程发起read操作之后，立刻就可以开始去做其它的事。而另一方面，从kernel的角度，
# 当它受到一个asynchronous read之后，首先它会立刻返回，所以不会对用户进程产生任何block。然后，
# kernel会等待数据准备完成，然后将数据拷贝到用户内存，当这一切都完成之后，kernel会给用户进程发送一个signal，
# 告诉它read操作完成了
# 代码
# import selectors
# from socket import *
#
# def accept(sk,mask):
# conn,addr=sk.accept()
# sel.register(conn,selectors.EVENT_READ,read)
#
# def read(conn,mask):
# try:
# data=conn.recv(1024)
# if not data:
# print('closing',conn)
# sel.unregister(conn)
# conn.close()
# return
# conn.send(data.upper()+b'_SB')
# except Exception:
# print('closing', conn)
# sel.unregister(conn)
# conn.close()
#
# sk=socket()
# sk.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
# sk.bind(('127.0.0.1',8088))
# sk.listen(5)
# sk.setblocking(False) #设置socket的接口为非阻塞
# sel=selectors.DefaultSelector() # 选择一个适合我的IO多路复用的机制
# sel.register(sk,selectors.EVENT_READ,accept)
#相当于网select的读列表里append了一个sk对象,并且绑定了一个回调函数accept
# 说白了就是 如果有人请求连接sk,就调用accrpt方法
# while True:
# events=sel.select() #检测所有的sk,conn，是否有完成wait data阶段
# for sel_obj,mask in events: # [conn]
# callback=sel_obj.data #callback=read
# callback(sel_obj.fileobj,mask) #read(conn,1)
