十二、协程

一、从生成器到协程

1.简单的生成器

Python2.3中，加入了新的关键字yield

在PEP255中，引入了yield表达式

规定yield语句只能在函数中使用。包含yield语句的函数被称为生成器函数。

当执行到yield语句是，函数的状态会被冻结（挂起所有状态，如：局部变量、指令指针、堆栈状态等），以便下载调用next时恢复状态继续执行 

2.通过生成器实现协程

协程的底层架构是在 PEP 342 中定义，在 Python2.5 实现的。

实现思想：使用yield挂起生成器，使用send 方法激活生成器。这样生成器就具备实现协程的功能。

执行 generator.send(None) 完全等同于调用生成器的 next 方法。使用其它参数调用 send 也有同样的效果，不同的是，当前生成器表达式产生的值会不一样。

参考资料：PEP 342 Coroutines via Enhanced Generators 

3.协程的演变

Python2 中生成器中 return 语句提供值，会抛出 SyntaxError 异常。

Python3 中生成器可以 return 一个值,

Python3.3 增加了 yield from 语法，使调用嵌套生成器变得简单

Python3.5 加入了关键字 async 和 await ，将生成器和协程彻底分开。

参考资料：

• PEP 380 Syntax for Delegating to a Subgenerator
• PEP 525 Asynchronous Generators

二、函数是如何执行的

Python 解释器是基于栈的，其中有三种栈：调用栈 (frame stack)、数据栈 (data  stack)、块栈 (block statck)。

对于Python编译器来说，PyCodeObject对象是其真正的编译结果。

在代码运行时，字节码会存储在 PyCodeObject 对象中。PyCodeObject 保存的是编译后的静态信息，在运行的时候会结合上下文形成一个完整的运行态环境。

函数的 __code__ 变量其实就是函数的编译后的PyCodeObject对象 

"""
解释器：解释字节码（若干指令）
1.生成字节码
2.生成指令，解释器去执行指令
"""

import dis
import inspect


def add(a, b):
    result = a + b
    return result


def main(x, y):
    i = 1
    print("main is  running...")
    py_obj = inspect.currentframe()  # 获得当前PyObject
    print(py_obj)
    print(py_obj.f_code is main.__code__)  # True
    print(py_obj.f_locals)
    print(py_obj.f_globals)
    result = add(x, y)
    return result


def f():
    pass


if __name__ == '__main__':
    print(main(10, 20))
    print(dis.dis(main))
    print(main.__code__.co_code)
    print(list(main.__code__.co_code))
    print(dis.opname[100])  # LOAD_CONST  100,1  LOAD_CONST 1
    print(dis.opname[125])  # STORE_FAST
    print(type(main.__code__))
    # __code__ 是  PyCodeObject对象， 保存的是上下文信息
    # 局部变量   常量   函数名等
    print(main.__code__.co_varnames)  # 变量
    print(main.__code__.co_consts)  # 常量
    print(main.__code__.co_names)  # 名字
    f.__code__ = main.__code__
    print(f(100, 200))

'''
main is  running...
<frame at 0x0000022EC73A2440, file 'D:/Program Files (x86)/PyCharm/workspace/test/test1.py', line 18, code main>
True
{'x': 10, 'y': 20, 'i': 1, 'py_obj': <frame at 0x0000022EC73A2440, file 'D:/Program Files (x86)/PyCharm/workspace/test/test1.py', line 20, code main>}
{'__name__': '__main__', '__doc__': '
解释器 解释 字节码（若干指令）
', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000022EC723F8E0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/Program Files (x86)/PyCharm/workspace/test/test1.py', '__cached__': None, 'dis': <module 'dis' from 'D:\Program Files (x86)\Python38\lib\dis.py'>, 'inspect': <module 'inspect' from 'D:\Program Files (x86)\Python38\lib\inspect.py'>, 'add': <function add at 0x0000022EC7387430>, 'main': <function main at 0x0000022EC7457F70>, 'f': <function f at 0x0000022EC7600550>}
30
 15           0 LOAD_CONST               1 (1)
              2 STORE_FAST               2 (i)

 16           4 LOAD_GLOBAL              0 (print)
              6 LOAD_CONST               2 ('main is  running...')
              8 CALL_FUNCTION            1
             10 POP_TOP

 17          12 LOAD_GLOBAL              1 (inspect)
             14 LOAD_METHOD              2 (currentframe)
             16 CALL_METHOD              0
             18 STORE_FAST               3 (py_obj)

 18          20 LOAD_GLOBAL              0 (print)
             22 LOAD_FAST                3 (py_obj)
             24 CALL_FUNCTION            1
             26 POP_TOP

 19          28 LOAD_GLOBAL              0 (print)
             30 LOAD_FAST                3 (py_obj)
             32 LOAD_ATTR                3 (f_code)
             34 LOAD_GLOBAL              4 (main)
             36 LOAD_ATTR                5 (__code__)
             38 COMPARE_OP               8 (is)
             40 CALL_FUNCTION            1
             42 POP_TOP

 20          44 LOAD_GLOBAL              0 (print)
             46 LOAD_FAST                3 (py_obj)
             48 LOAD_ATTR                6 (f_locals)
             50 CALL_FUNCTION            1
             52 POP_TOP

 21          54 LOAD_GLOBAL              0 (print)
             56 LOAD_FAST                3 (py_obj)
             58 LOAD_ATTR                7 (f_globals)
             60 CALL_FUNCTION            1
             62 POP_TOP

 22          64 LOAD_GLOBAL              8 (add)
             66 LOAD_FAST                0 (x)
             68 LOAD_FAST                1 (y)
             70 CALL_FUNCTION            2
             72 STORE_FAST               4 (result)

 23          74 LOAD_FAST                4 (result)
             76 RETURN_VALUE
None
b'dx01}x02tx00dx02x83x01x01x00tx01xa0x02xa1x00}x03tx00|x03x83x01x01x00tx00|x03jx03tx04jx05kx08x83x01x01x00tx00|x03jx06x83x01x01x00tx00|x03jx07x83x01x01x00tx08|x00|x01x83x02}x04|x04Sx00'
[100, 1, 125, 2, 116, 0, 100, 2, 131, 1, 1, 0, 116, 1, 160, 2, 161, 0, 125, 3, 116, 0, 124, 3, 131, 1, 1, 0, 116, 0, 124, 3, 106, 3, 116, 4, 106, 5, 107, 8, 131, 1, 1, 0, 116, 0, 124, 3, 106, 6, 131, 1, 1, 0, 116, 0, 124, 3, 106, 7, 131, 1, 1, 0, 116, 8, 124, 0, 124, 1, 131, 2, 125, 4, 124, 4, 83, 0]
LOAD_CONST
STORE_FAST
<class 'code'>
('x', 'y', 'i', 'py_obj', 'result')
(None, 1, 'main is  running...')
('print', 'inspect', 'currentframe', 'f_code', 'main', '__code__', 'f_locals', 'f_globals', 'add')
main is  running...
<frame at 0x0000022EC758B040, file 'D:/Program Files (x86)/PyCharm/workspace/test/test1.py', line 18, code main>
True
{'x': 100, 'y': 200, 'i': 1, 'py_obj': <frame at 0x0000022EC758B040, file 'D:/Program Files (x86)/PyCharm/workspace/test/test1.py', line 20, code main>}
{'__name__': '__main__', '__doc__': '
解释器 解释 字节码（若干指令）
', '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000022EC723F8E0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'D:/Program Files (x86)/PyCharm/workspace/test/test1.py', '__cached__': None, 'dis': <module 'dis' from 'D:\Program Files (x86)\Python38\lib\dis.py'>, 'inspect': <module 'inspect' from 'D:\Program Files (x86)\Python38\lib\inspect.py'>, 'add': <function add at 0x0000022EC7387430>, 'main': <function main at 0x0000022EC7457F70>, 'f': <function f at 0x0000022EC7600550>}
300

'''

三、生成器是如何执行的

YIELD_VALUE 指令，挂起当前函数
 

调用生成器函数时，生成器不会立即执行，而是返回一个生成器对象。生成器对象有 gi_code 和 gi_frame 两个常用的属性，gi_code 和 code 一样存放了字节码，gi_frame 中存储了运行时的数据。

使用 send 方法也可以使生成器继续执行，和 next 不同的是，send 方法可以向生成器传入值

yield 之后和之前的代码执行是分离的，函数在遇到 yield 会交出控制权，send方法会重新获取控制权。

import dis
import inspect

def f():
    i = 1
    return i

def gen():

    print("gen is running...")
    i = yield 1  # YIELD_VALUE 指令
    print('aaaaa')
    print('xxxxx')
    yield 2
    print("aaaaa")
    yield 3
    return None

def gen_test():
    """
    g = gen()  :  创建生成器对象
    g.gi_code ： 存的gen()函数的字节码，保存的是上下文信息， 和 gen.__code__是一样的
    g.gi_frame： 存储的是运行时的数据
    g.gi_frame.f_lasti ： 上一次执行的指令的位置
    遇到yield就挂起
    遇到next就激活
    """
    print(dis.dis(f))
    print(dis.dis(gen))
    g = gen()
    print(g.gi_code is gen.__code__)  # True
    print(g.gi_frame.f_lasti)  # 记录执行到第几行, 默认是-1 （-1代表还没有执行）
    # 查看生成器状态
    print(inspect.getgeneratorstate(g))  # GEN_CREATED  创建完毕
    next(g)
    next(g)
    print(g.gi_frame.f_lasti)
    next(g)
    print(g.gi_frame.f_lasti)
    print(inspect.getgeneratorstate(g))  # GEN_SUSPENDED  挂起
    for i in g:
        pass

    print(inspect.getgeneratorstate(g))  # GEN_CLOSED  生成器结束


if __name__ == '__main__':
    gen_test()

'''
  6           0 LOAD_CONST               1 (1)
              2 STORE_FAST               0 (i)

  7           4 LOAD_FAST                0 (i)
              6 RETURN_VALUE
None
 12           0 LOAD_GLOBAL              0 (print)
              2 LOAD_CONST               1 ('gen is running...')
              4 CALL_FUNCTION            1
              6 POP_TOP

 13           8 LOAD_CONST               2 (1)
             10 YIELD_VALUE
             12 STORE_FAST               0 (i)

 14          14 LOAD_GLOBAL              0 (print)
             16 LOAD_CONST               3 ('aaaaa')
             18 CALL_FUNCTION            1
             20 POP_TOP

 15          22 LOAD_GLOBAL              0 (print)
             24 LOAD_CONST               4 ('xxxxx')
             26 CALL_FUNCTION            1
             28 POP_TOP

 16          30 LOAD_CONST               5 (2)
             32 YIELD_VALUE
             34 POP_TOP

 17          36 LOAD_GLOBAL              0 (print)
             38 LOAD_CONST               3 ('aaaaa')
             40 CALL_FUNCTION            1
             42 POP_TOP

 18          44 LOAD_CONST               6 (3)
             46 YIELD_VALUE
             48 POP_TOP

 19          50 LOAD_CONST               0 (None)
             52 RETURN_VALUE
None
True
-1
GEN_CREATED
gen is running...
aaaaa
xxxxx
32
aaaaa
46
GEN_SUSPENDED
GEN_CLOSED
'''

四、使用生成器实现多任务 

"""
虽然实现了并发，但是不能检测IO阻塞
"""

import time


def calc_time(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f'执行时间是:{end_time - start_time}')
        return result

    return wrapper


def work1():
    for i in range(5):
        print(f'听音乐....{i}')
        time.sleep(1)
        yield


def work2():
    for i in range(5):
        time.sleep(1)
        print(f'打游戏....{i}')
        yield

@calc_time
def main():
    g1 = work1()
    g2 = work2()

    while True:
        try:
            next(g1)
            next(g2)
        except StopIteration:
            break

if __name__=='__main__':
    main()

'''
听音乐....0
打游戏....0
听音乐....1
打游戏....1
听音乐....2
打游戏....2
听音乐....3
打游戏....3
听音乐....4
打游戏....4
执行时间是:10.009641408920288
'''

什么时候报异常：

五、gevent实现异步

 gevent 是应用非常广泛的异步网络库，底层使用 greenlet 协程

"""
gevent 默认遇到gevent.sleep会自动切换
遇到普通的io阻塞，不会切换任务，如果要实现自动切换，需要加  monkey.patch_all()
"""


import time

from gevent import monkey

monkey.patch_all()
import gevent


def calc_time(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f'执行时间是:{end_time - start_time}')
        return result

    return wrapper


def work1():
    for i in range(5):
        print(f'听音乐....{i}')
        # time.sleep(1)  # 不会切换任务，执行work1完毕后在执行work2
        gevent.sleep(60*5)


def work2():
    for i in range(5):
        time.sleep(1)  # gevent能自动检测io阻塞，遇到阻塞自动切换任务
        print(f'打游戏....{i}')


@calc_time
def main():
    g1 = gevent.spawn(work1)  # 协程1
    g2 = gevent.spawn(work2)  # 协程2
    g1.join()
    g2.join()


if __name__ == '__main__':
    main()

'''
听音乐....0
打游戏....0
打游戏....1
打游戏....2
打游戏....3
打游戏....4
听音乐....1
听音乐....2
听音乐....3
听音乐....4
执行时间是:1500.1551814079285
'''

 六、asycio实现协程 

"""
async 函数: 标识函数是一个异步任务
await 耗时的操作 : 挂起耗时的操作，自动切换到别的任务上"""


import time
import asyncio

def calc_time(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f'执行时间是:{end_time - start_time}')
        return result

    return wrapper

async def work1():
    for i in range(5):
        await asyncio.sleep(2)
        print(f'听音乐....{i}')

async def work2():
    for i in range(5):
        await asyncio.sleep(1)
        print(f'打游戏....{i}')


async def main():
    task1 = asyncio.create_task(work1())
    task2 = asyncio.create_task(work2())
    await task1
    await task2


if __name__ == '__main__':
    asyncio.run(main())

'''
打游戏....0
听音乐....0
打游戏....1
打游戏....2
听音乐....1
打游戏....3
打游戏....4
听音乐....2
听音乐....3
听音乐....4

'''

七、协程的核心思想

为了实现异步io
若干个协程任务，当某个任务遇到阻塞时，自动切换到非阻塞的任务上。
阻塞： io阻塞。 如： input("请输入一个数：") , 磁盘io（写数据是需要时间的），网络io（网络请求数据是需要时间的）
time.sleep(2)
用户态 ： 切换不需要CPU调度
核心态： 线程切换，进程切换，核心态 ， 切换需要CPU调度