并行和并发

并行：在操作系统中是指，一组程序按独立异步的速度执行，无论从微观还是宏观，程序都是一起执行的。
并发：在操作系统中，是指一个时间段中有多个已启动的程序运行在同一个执行机上，多个程序交替着切换执行，但任一个时刻点上只有一个程序在处理机上运行。宏观上给人并行的表现，微观上仍是顺序执行

阻塞非阻塞

阻塞和非阻塞指的是调用者（程序）在等待返回结果（或输入）时的状态。
阻塞：在调用结果返回前，当前线程会被挂起，并在得到结果之后返回。
非阻塞：如果不能立刻得到结果，则该调用者当前线程还可以先干些别的事儿，不会阻塞当前线程，同时调用者需要定时轮询查看处理状态。

同步/异步

同步：在发出一个同步调用时，在没有得到结果之前，该调用就不返回。
异步：在发出一个异步调用后，调用者不会立刻得到结果，该调用就返回了

简单使用

# python 源码
import asyncio
import time


async def task(task_name):
    print(task_name, 'start')
    await asyncio.sleep(5)
    print(task_name, 'end')
    return task_name


async def main():
    print('task_main', 'start')
    # 创建两个任务，等待运行
    task1 = task("task_01")
    task2 = task("task_02")
    a = await task1
    b = await task2
    print(a, b)
    print('task_main', 'end')

if __name__ == '__main__':
    t = time.time()
    # 方式一
    loop = asyncio.get_event_loop()  # 创建事件循环
    loop.run_until_complete(main())  # 添加任务，直至所有任务执行完成
    loop.close()  # 关闭事件循环，事件循环关闭后，再次调用loop，将不会再次执行

    # 方式二，python3.7省略的手动创建事件循环，可直接用asyncio.run()去执行协程任务。
    asyncio.run(main())

    print('总耗时：', time.time() - t)

上面例子task1和task2都是异步执行，但需要等待执行结果才能执行下一个任务，因此task1和task2将会是顺序执行，如果想并发执行则需要采用asyncio.create_task()声明为异步任务，先统一执行，后统一等待结果

创建异步任务

修改main函数
asyncio: Task, create_task, ensure_future 都可以创建任务，该用哪个？

async def main():
    print('task_main', 'start')
    # 创建两个任务，等待运行
    task1 = asyncio.create_task(task("task_01"))
    task2 = asyncio.create_task(task("task_02"))
    a = await task1
    b = await task2
    print(a, b)
    print('task_main', 'end')

执行过程分析

import asyncio
import time


async def task(task_name):
    print(task_name, 'start')
    await asyncio.sleep(5)
    print(task_name, 'end')
    return task_name


async def main():
    print('task_main', 'start')

    # 创建四个任务，等待运行
    task1 = asyncio.create_task(task("task_01"))
    task2 = asyncio.create_task(task("task_02"))

    # 休眠5秒钟，可以看到四个任务没有打印输出
    # 那是因为time.sleep是阻塞的，由于只有一个线程，而此时线程正在被休眠独自占用，没有io等耗时任务，不会发生协程切换
    print('线程休眠开始')
    time.sleep(5)
    print('线程休眠结束，协程有机会或则执行权')
    # time.sleep执行结束，线程不再被阻塞，四个task有机会得到执行，因为四个task内部有耗时任务（阻塞），因此会协程会相互切换，达到类似并行的效果，本质还是并发

    # 等待协程task执行完毕，主线程在结束
    # 1. 给足够的时间让task执行完毕，否则协程还没执行完毕，主线程就已经结束了
    await asyncio.sleep(5)
    # 2. 或者分别等待每个task结束，类似多线程中task.join()
    print('task_main', 'running')
    a = await task1
    b = await task2
    print(a, b)
    print('task_main', 'end')


if __name__ == '__main__':
    t = time.time()
    asyncio.run(main())
    print('总耗时：', time.time() - t)

asyncio.gather 用法

返回的是所有已完成 Task 的 result，不需要再进行调用或其他操作，就可以得到全部结果
最常见的用法是：await asyncio.gather(*task_list)，注意这里 task_list 前面有一个 *。


async def main():
    print('task_main', 'start')
    # 创建两个任务，等待运行
    task1 = asyncio.create_task(task("task_01"))
    task2 = asyncio.create_task(task("task_02"))
    results = await asyncio.gather(*[task1, task2])
    for result in results:
        print('结果输出：', result)
    print('task_main', 'end')

不用create_task也一样

async def main():
    print('task_main', 'start')
    # 创建两个任务，等待运行
    results = await asyncio.gather(*[task("task_01"), task("task_02")])
    print(results)
    print('task_main', 'end')

asyncio.wait 用法

asyncio.wait 会返回两个值：done（已完成的协程task）和 pending（超时未完成的协程task），需通过 future.result()获取返回值。
最常见的写法是：await asyncio.wait(task_list)，修改main函数

async def main():
    print('task_main', 'start')

    # 创建两个任务，等待运行
    task1 = asyncio.create_task(task("task_01"))
    task2 = asyncio.create_task(task("task_02"))
    done, pending = await asyncio.wait([task1, task2])
    for done_task in done:
        print('结果输出：', done_task.result())
    print('task_main', 'end')