协程

1.引子

为什么有协程? 是为了使用单线程实现并发(多个任务看起来是同时运行的)的效果 , 即只用一个主线程（很明显可利用的cpu只有一个）情况下实现并发

回顾下并发的本质：切换+保存状态

多道技术
    切换+保存状态
    CPU两种切换
        1.程序遇到io
        2.程序长时间占用

"""
进程 : 资源单位
线程 : 执行单位
协程 : 这个概念完全是程序员自己意淫出来的根本不存在
         单线程下实现并发
         我们程序员自己再代码层面上检测我们所有的Io操作
        旦遇到ro了我们在代码级别完成切换
        这样给CPU的感觉是你这个程序一直在运行没有Io
        从而提升程序的运行效率
        
代码如何做到
	切换+保存状态

切换
	切换不一定是提升效率也有可能是降低效率
	io切         提升
	没有io切   降低

保存状态
	保存上一次我执行的状态  下一次来接着上一次的操作继续往后执行
	yield
"""

通过我们自己写的代码 , 让我们的代码自动切换 , 用我们自己写的代码监听IO , 一旦遇到IO代码层面自动切换 , 给cpu的感觉是你一直在忙 , 欺骗cpu

2.什么是协程

"""
协程：是单线程下的并发，又称微线程，纤程。英文名Coroutine。
一句话说明什么是协程：协程是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的。
"""

强调

#1. python的线程属于内核级别的，即由操作系统控制调度（如单线程遇到io或执行时间过长就会被迫交出cpu执行权限，切换其他线程运行）

#2. 单线程内开启协程，一旦遇到io，就会从应用程序级别（而非操作系统）控制切换，以此来提升效率（！！！非io操作的切换与效率无关）

协程的优缺点

#1. 协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
#2. 单线程内就可以实现并发的效果，最大限度地利用cpu

#1. 协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程
#2. 协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程

协程的特点

1.必须在只有一个单线程里实现并发
2.修改共享数据不需加锁
3.用户程序里自己保存多个控制流的上下文栈

既然要我们自己写的代码监听IO , 那怎么使用代码监听IO操作呢?gevent模块已经帮你封装好了

3.gevent模块

pip3 install gevent

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的返回值

但是gevent只能检测自己模块下的一些io操作 , 无法检测一些常见的IO操作, 比如time.sleep() , sock.accept() , 需要使用者自己在前面加上一行代码

举例 :

from gevent import monkey;monkey.patch_all()  # 这是必须要加的一句话from gevent import spawnimport timedef heng():    print('哼')    # 模拟io    time.sleep(2)    print('哼')def ha():    print('哈')    # 模拟io    time.sleep(3)    print('哈')start_time = time.time()g1 = spawn(heng)  # 会监测heng函数里面的io操作,异步提交任务g2 = spawn(ha)g1.join()  # 等待被监测的任务执行完毕后再往后继续执行g2.join()# print(time.time()-start_time)   # 同步 5.017256021499634print(time.time() - start_time)  # 3.0250768661499023

spawn监测两个任务的时候 , 首先会打印print('哼') . 然后瞬间要time.sleep(2) , 然后程序立马跳到ha() , 打印一个 print('哈') , 然后又瞬间要time.sleep(3) , 然后程序要切换回去 , 切换过去还是在睡 , 再切回来 , 来来回回一直在切换 , cpu的感知是你还在用我 , 然后直到2秒过去 , 再打印

再加一个任务

from gevent import monkey;monkey.patch_all()from gevent import spawnimport timedef heng():    print('哼')    # 模拟io    time.sleep(2)    print('哼')def ha():    print('哈')    # 模拟io    time.sleep(3)    print('哈')def heiheihei():    print('嘿嘿嘿')    # 模拟io    time.sleep(5)    print('嘿嘿嘿')start_time = time.time()g1 = spawn(heng)  # 会监测heng函数里面的io操作,异步提交任务g2 = spawn(ha)g3 = spawn(heiheihei)g1.join()  # 等待被监测的任务执行完毕后再往后继续执行g2.join()g3.join()print(time.time() - start_time)  # 5.014261245727539

切换 + 保存状态 , 从而提升单线程下的cpu的利用率 , 开发项目也不需要你写这样的代码 , 做一个理论了解

4.协程实现tcp并发

服务端

from gevent import monkey;monkey.patch_all()from gevent import spawnimport socket# 进行通信的任务函数def communication(conn):    while 1:        try:            msg = conn.recv(1024)            if not msg: break            print(msg.decode())            conn.send(msg.upper())        except Exception:            pass    conn.close()# 一直提供服务的任务函数def server(ip, port):    server_sock = socket.socket()    server_sock.bind((ip, port))    server_sock.listen(5)    while 1:        conn, addr = server_sock.accept()        spawn(communication, conn)if __name__ == '__main__':    g1 = spawn(server, '127.0.0.1', 8080)  # accept 和 recv一直在切换    g1.join()

客户端

from threading import Thread, current_threadimport socketdef x_client():    sock = socket.socket()    sock.connect(('127.0.0.1', 8080))    n = 0    while 1:        msg = f"{current_thread().name} say hello {n}"        n += 1        sock.send(msg.encode())        data = sock.recv(1024)        print(data.decode())if __name__ == '__main__':    for i in range(400):        t = Thread(target=x_client)        t.start()