python并发编程

1.协程

示例1：

import time
import asyncio

async def crawl_page(url):
    print('crawling {}'.format(url))
    sleep_time = int(url.split('_')[-1])
    await asyncio.sleep(sleep_time)
    print('OK {}'.format(url))
async def main(urls):
    for url in urls:
        #await 执行，程序会阻塞在这里，进入被调用的协成函数crawl_page，执行完毕后再继续。
        #是同步调用，在当前调用结束之前，是不会触发下次调用
       await crawl_page(url)
#事件循环作为主程序的入口
asyncio.run(main(['url_1', 'url_2', 'url_3', 'url_4']))

'''
结果：
crawling url_1
    等待1s.......
OK url_1
crawling url_2
    等待2s.....
OK url_2
crawling url_3
    等待3s........
OK url_3
crawling url_4
    等待4s........
OK url_4
'''

花费的时间1+2+3+4 为10s.

示例2：

async def crawl_page_1(url):
    print('crawling {}'.format(url))
    sleep_time = int(url.split('_')[-1])
    await asyncio.sleep(sleep_time)
    print('OK {}'.format(url))

async def main_1(urls):
    #任务创建后会很快的被调用，任务就不会阻塞在这里。
    tasks = [asyncio.create_task(crawl_page_1(url)) for url in urls ]
    for task in tasks:
        await task
#事件循环作为主程序的入口
asyncio.run(main_1(['url_1', 'url_2', 'url_3', 'url_4']))

'''
结果：
crawling url_1
crawling url_2
crawling url_3
crawling url_4
OK url_1
OK url_2
OK url_3
OK url_4
'''

花费的时间为将近4s.

协程的执行解释：

import asyncio

async def worker_1():
    print('worker_1 start')
    await asyncio.sleep(1)
    print('worker_1 done')

async def worker_2():
    print('worker_2 start')
    await asyncio.sleep(2)
    print('worker_2 done')

async def main():
    task1 = asyncio.create_task(worker_1())
    task2 = asyncio.create_task(worker_2())
    print('before await')
    await task1
    print('awaited worker_1')
    await task2
    print('awaited worker_2')

asyncio.run(main())


'''
执行结果：
before await
worker_1 start
worker_2 start
worker_1 done
awaited worker_1
worker_2 done
awaited worker_2
'''

asyncio.run(main())，程序进入 main() 函数，事件循环开启；

task1 和 task2 任务被创建，并进入事件循环等待运行；运行到 print，输出 'before await'；

await task1 执行，用户选择从当前的主任务中切出，事件调度器开始调度 worker_1；

worker_1 开始运行，运行 print 输出'worker_1 start'，然后运行到 await asyncio.sleep(1)， 从当前任务切出，事件调度器开始调度 worker_2；

worker_2 开始运行，运行 print 输出 'worker_2 start'，然后运行 await asyncio.sleep(2) 从当前任务切出；

以上所有事件的运行时间，都应该在 1ms 到 10ms 之间，甚至可能更短，事件调度器从这个时候开始暂停调度；

一秒钟后，worker_1 的 sleep 完成，事件调度器将控制权重新传给 task1，输出 'worker_1 done'，task_1 完成任务，从事件循环中退出；

await task1 完成，事件调度器将控制器传给主任务，输出 'awaited worker_1'，·然后在 await task2 处继续等待；

两秒钟后，worker_2 的 sleep 完成，事件调度器将控制权重新传给 task2，输出 'worker_2 done'，task_2 完成任务，从事件循环中退出；

主任务输出 'awaited worker_2'，协程全任务结束，事件循环结束。