Python 协程和异步IO详解

1. 协程的使用

def coroutine_example(name):
    print('start coroutine...name:', name)

    while True:
        x = yield name #调用next()时，产出yield右边的值后暂停；调用send()时，产出值赋给x，并往下运行
        if x is None:
            return 'zhihuID: Zarten'
        print('send值:', x)

coro = coroutine_example('Zarten') #corutine对象不会立即执行函数体
next(coro)
print('send的返回值:', coro.send(6))
try:
    coro.send(None)
except StopIteration as e:
    print('返回值：', e.value)

• 调用next()时，会产出yield右边的值然后暂停

• 调用send()时，产出值会赋值给yield左边的值然后继续运行

• 必须先调用next()函数预激活协程，否则send()函数无法使用

  TypeError: can't send non-None value to a just-started generator

• 当结束协程时，会返回返回值，在StopIteration的value属性中

2. yield from语法配合协程的使用

def coroutine_example(name):
    print('start coroutine...name:', name)
    x = yield name #调用next()时，产出yield右边的值后暂停；调用send()时，产出值赋给x，并往下运行
    print('send值:', x)
    return 'zhihuID: Zarten'

def grouper2():
    result2 = yield from coroutine_example('Zarten') #在此处暂停，等待子生成器的返回后继续往下执行
    print('result2的值：', result2)
    return result2

def grouper():
    result = yield from grouper2() #在此处暂停，等待子生成器的返回后继续往下执行
    print('result的值：', result)
    return result

def main():
    g = grouper()
    next(g)
    try:
        g.send(10)
    except StopIteration as e:
        print('返回值：', e.value)

if __name__ == '__main__':
    main()

• yield from x内部会自动捕获StopIteration异常，并把异常对象的value变成yeild from表达式的值

  yield from x表示式内部首先调用iter(x)，然后再调用next()，因此x是任何可迭代对象。

• yield from的主要作用是打开双向通道，把最外层的调用方和最内层的子生成器连接起来

  上面代码可以看出，yield from起到了一个双向通道的作用，同时子生成器也可以使用yield from调用另一个子生成器，直到遇到yield表达式结束链式。yield from一般用于asyncio模块做异步IO

3. 异步IO (asyncio)

3.1 概念

异步IO使用asyncio库使用事件循环驱动协程实现并发，用户可以主动控制程序，在认为耗时IO处添加await(yield from)

1. 事件循环

   管理所有的事件，在整个程序运行过程中不断循环执行并追踪事件发生的顺序将他们放在队列中，空闲时调用相应的事件处理者来处理这些事件。

2. Future

   Future表示尚未完成的计算，还未完成的结果

3. Task

   Future的子类，作用是在运行某个任务的同时可以并发运行多个任务。

   asyncio.Task是用于实现协程多任务的库，且Task对象不能手动实例化，通过下面两个函数创建：

   asyncio.async()

   loop.create_task()或asyncio.ensure_future()

3.2 异步IO使用示例

import asyncio

async def coroutine_example():
    await asyncio.sleep(1)
    print('zhihu ID: Zarten')

coro = coroutine_example()

loop = asyncio.get_event_loop()
task = loop.create_task(coro)
print('运行情况：', task)

loop.run_until_complete(task)
print('再看下运行情况：', task)
loop.close()

• loop.create_task()接收一个协程对象，返回一个Task实例，返回值可以直接传入```run_until_complete()``
• run_until_complete()阻塞调用，直到协程运行结束才返回，参数是Future，传入协程对象时内部会自动变为future。
• asyncio.sleep()模拟IO操作，这样的休眠不会阻塞时间循环，前面加上await会把控制权交给主事件循环，在结束后恢复这个协程
• task.result()可以用来获取协程的返回值，但是不会阻塞等待，只有协程运行完毕后才能获取。（或者使用task.add_done_callback）

import asyncio

async def coroutine_example(name):
    print('正在执行name:', name)
    await asyncio.sleep(1)
    print('执行完毕name:', name)

loop = asyncio.get_event_loop()

tasks = [coroutine_example('Zarten_' + str(i)) for i in range(3)]
wait_coro = asyncio.wait(tasks)
loop.run_until_complete(wait_coro)
loop.close()

• asyncio.wait()可以控制多任务，返回是一个协程，不会阻塞立即返回，传入参数是Future或协程构成的可迭代对象

3.3 动态添加协程

方案是创建一个线程，使事件循环在线程内永久运行

1. 同步方式

   import asyncio
   from threading import Thread
   
   def start_thread_loop(loop):
       asyncio.set_event_loop(loop)
       loop.run_forever()
   
   def thread_example(name):
       print('正在执行name:', name)
       return '返回结果：' + name
   
   
   new_loop = asyncio.new_event_loop()
   t = Thread(target= start_thread_loop, args=(new_loop,))
   t.start()
   
   handle = new_loop.call_soon_threadsafe(thread_example, 'Zarten1')
   handle.cancel()
   
   new_loop.call_soon_threadsafe(thread_example, 'Zarten2')
   
   print('主线程不会阻塞')
   
   new_loop.call_soon_threadsafe(thread_example, 'Zarten3')
   
   print('继续运行中...')
   

2. 异步方式

   import asyncio
   from threading import Thread
   
   def start_thread_loop(loop):
       asyncio.set_event_loop(loop)
       loop.run_forever()
   
   async def thread_example(name):
       print('正在执行name:', name)
       await asyncio.sleep(1)
       return '返回结果：' + name
   
   
   
   new_loop = asyncio.new_event_loop()
   t = Thread(target= start_thread_loop, args=(new_loop,))
   t.start()
   
   future = asyncio.run_coroutine_threadsafe(thread_example('Zarten1'), new_loop)
   print(future.result()) #这里reslut结果是阻塞调用的
   
   asyncio.run_coroutine_threadsafe(thread_example('Zarten2'), new_loop)
   
   print('主线程不会阻塞')
   
   asyncio.run_coroutine_threadsafe(thread_example('Zarten3'), new_loop)
   
   print('继续运行中...')
   

实际生产代码中，建议把启动事件循环的线程设为守护线程