asyncio

asyncio是python用于解决异步io编程的一整套解决方案

1.使用asyncio

import asyncio
import time
async def get_html(url):
    print("start get url")
    await asyncio.sleep(2)   # 耗时操做 要加await
    print("end get url")

if __name__ == "__main__":
    start_time = time.time()
    loop = asyncio.get_event_loop()  # 建立event_loop 对象    若是要建立新的event_loop对象 须要使用asyncio.new_event_loop()
    tasks = [get_html("http://www.imooc.com") for i in range(10)]
    loop.run_until_complete(asyncio.wait(tasks))   # run_until_complete() 启动协程  asyncio.wait(tasks) 循环多个asyncis.wait(可迭代对象,启动多个对象)
    loop.run_until_complete(asyncio.gather(tasks))
    print(time.time()-start_time)

# gather和wait的区别
# gather比wait更加高一级   推荐使用gather
    group1 = [get_html("http://projectsedu.com") for i in range(2)]
    group2 = [get_html("http://www.imooc.com") for i in range(2)]
    group1 = asyncio.gather(*group1)
    group2 = asyncio.gather(*group2)
    group2.cancel()
    loop.run_until_complete(asyncio.gather(group1, group2))
    print(time.time() - start_time)

# 结果     能够在2秒能完成全部的并发
start get url
start get url
start get url
start get url
start get url
start get url
start get url
start get url
start get url
start get url
end get url
end get url
end get url
end get url
end get url
end get url
end get url
end get url
end get url
end get url
2.003009080886841

2.获取协程的返回值,函数完成时回调

import asyncio
import time
from functools import partial


async def get_html(url):
    print("start get url")
    await asyncio.sleep(2)
    return "bobby"


def callback(url, future):
    print(url)
    print("send email to bobby")


if __name__ == "__main__":
    start_time = time.time()
    loop = asyncio.get_event_loop()   # asyncio.get_event_loop方法能够建立一个事件循环 建立event_loop 对象    若是要建立新的event_loop对象 须要使用asyncio.new_event_loop()
    # get_future = asyncio.ensure_future(get_html("http://www.imooc.com"))
    task = loop.create_task(get_html("http://www.imooc.com"))   # asyncio.ensure_future 和 loop.create_task均可以建立一个task，   任务对象task    实际上是run_until_complete方法将协程包装成为了一个任务（task）对象。所谓task对象是Future类的子类。保存了协程运行后的状态，用于将来获取协程的结果。
    task.add_done_callback(partial(callback, "http://www.imooc.com"))  # add_done_callback 执行函数的回调   partial能够给回调函数添加参数
    loop.run_until_complete(task)  # run_until_complete将协程注册到事件循环，并启动事件循环
    print(task.result())   # task.result() 获取task返回值

3.取消future(task)

import asyncio
import time


async def get_html(sleep_times):
    print("waiting")
    await asyncio.sleep(sleep_times)
    print("done after {}s".format(sleep_times))


if __name__ == "__main__":
    task1 = get_html(2)
    task2 = get_html(3)
    task3 = get_html(3)

    tasks = [task1, task2, task3]

    loop = asyncio.get_event_loop()

    try:
        loop.run_until_complete(asyncio.wait(tasks))
    except KeyboardInterrupt as e:
        all_tasks = asyncio.Task.all_tasks()  # asyncio.Task.all_tasks()  获取全部的 tasks
        for task in all_tasks:
            print("cancel task")
            print(task.cancel())  # # 取消成功返回True，取消失败返回False
        loop.stop()  # 中止时间循环
        loop.run_forever()   # 从新启动事件循环   注释会抛异常
    finally:
        loop.close()

4.协程里面嵌套协程

import asyncio


async def compute(x, y):
    print('Compute %s + %s .....' % (x, y))
    await asyncio.sleep(1.0)
    return x + y


async def print_sum(x, y):
    result = await compute(x, y)
    print('%s + %s =%s' % (x, y, result))


loop = asyncio.get_event_loop()
loop.run_until_complete(print_sum(1, 2))
loop.close()

　

5.call_soon  下个循环当即执行

import asyncio


def callback(sleep_time):
    print('sleep {} success'.format(sleep_time))


def stoploop(loop):
    loop.stop()


if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.call_soon(callback, 2)  # 下个循环当即执行
    loop.call_soon(stoploop, loop)
    loop.run_forever()
    loop.close()　

6.call_later   多少秒以后执行

import asyncio


def callback(sleep_time):
    print('sleep {} success'.format(sleep_time))


def stoploop(loop):
    loop.stop()


if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.call_later(2, callback, 2.0)  # 2秒以后运行
    loop.call_later(1, callback, 1.0)  # 1秒以后运行
    loop.call_later(3, callback, 3.0)  # 3秒以后运行
    loop.run_forever()
    loop.close()

# 结果
sleep 1.0 success
sleep 2.0 success
sleep 3.0 success