import asyncio


async def first():
    print('first函數(shù)調用開始,下面將會等待3秒模擬函數(shù)運行完畢')
    await asyncio.sleep(3)
    print('first函數(shù)執(zhí)行完畢')


async def last():
    print('last函數(shù)調用開始')
    await asyncio.sleep(2)
    print('last函數(shù)執(zhí)行完畢')


async def func(delay):
    print('開始異步同時執(zhí)行的函數(shù)+延遲: ' + str(delay))
    await asyncio.sleep(delay)
    print('--異步函數(shù)執(zhí)行完畢+延遲: ' + str(delay))


async def main():
    await first()  # 這里先調用first()函數(shù),并且等它執(zhí)行完了才會開始
    await asyncio.gather(
        func(1),
        func(2),
        func(3)
    )
    await last()


asyncio.run(main())

loop = asyncio.get_event_loop()
task = loop.create_task(main())
loop.run_until_complete(task)

import asyncio

# 定義一個可以異步調用的函數(shù),其類型為coroutine
async def func1():
    pass

if __name__ == '__main__':
    loop = asyncio.get_event_loop()	# 定義一個用來循環(huán)異步函數(shù)的loop對象
    task = asyncio.ensure_future(func1())	# 創(chuàng)建一個調用異步函數(shù)的任務,task類型為future
    # task = loop.create_task(func1())	# 使用loop的.create_task()創(chuàng)建任務,效果一樣
    loop.run_until_complete(task)	# 開始在loop循環(huán)中執(zhí)行異步函數(shù),直到該函數(shù)運行完畢

import asyncio

# 這是一個耗時很少的異步函數(shù)
async def msg(text):	
    await asyncio.sleep(0.1)
    print(text)

# 這是一個耗時較長的異步函數(shù)
async def long_operation():
    print('long_operation started')
    await asyncio.sleep(3)
    print('long_operation finished')

# 主函數(shù)部分,同樣需要聲明為async異步類型
async def main():
    await msg('first')
    # 現(xiàn)在需要調用一個耗時較長的函數(shù)操作,不希望阻塞的等待它執(zhí)行完畢
    # 希望long_operation在開始執(zhí)行后,立即調用msg,這里就可以將long_operation封裝到task任務中
    task = asyncio.ensure_future(long_operation())
    await msg('second')
    # 開始task中的long_operation函數(shù)
    await task
    # task執(zhí)行完畢后會繼續(xù)下面的代碼
    print('All done.')

if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.run_until_complete(main())

import asyncio

import time

now = lambda: time.time()

async def do_some_work(x):
    print('Waiting: ', x)

    await asyncio.sleep(x)
    return 'Done after {}s'.format(x)

start = now()

coroutine1 = do_some_work(1)
coroutine2 = do_some_work(2)
coroutine3 = do_some_work(4)

tasks = [
    asyncio.ensure_future(coroutine1),
    asyncio.ensure_future(coroutine2),
    asyncio.ensure_future(coroutine3)
]

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

for task in tasks:
    print('Task ret: ', task.result())

print('TIME: ', now() - start)

import time
import asyncio

now = lambda : time.time()

async def do_some_work(x):
    print('Waiting: ', x)
    return 'Done after {}s'.format(x)

def callback(future):
    print('Callback: ', future.result())

start = now()

coroutine = do_some_work(2)
loop = asyncio.get_event_loop()
task = loop.create_task(coroutine)
#task = asyncio.ensure_future(coroutine)	# 貌似和上面用loop創(chuàng)建任務效果一樣
task.add_done_callback(callback)
loop.run_until_complete(task)

print('TIME: ', now() - start)

def create_task(coro):
    """Schedule the execution of a coroutine object in a spawn task.

    Return a Task object.
    """
    loop = events.get_running_loop()
    return loop.create_task(coro)

import asyncio

result_list = []


async def fun(var):
    return var + 1


def callbackFun(future):
    result_list.append(future.result())


task_list = []

for i in range(1, 5):
    cor = fun(i)
    task = asyncio.ensure_future(cor)
    task.add_done_callback(callbackFun)
    task_list.append(task)

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(task_list))
print(result_list)

# 前面省略
loop.run_until_complete(asyncio.wait(task_list))
# task_list中的每個任務執(zhí)行完成后可以調用它的.result()方法來獲取結果
for task in task_list:
    print('每個task執(zhí)行完的結果:', task.result())