Introdução: No último capítulo, introduziu o uso da fonte para o rendimento do assíncrono e, finalmente, para implementar co-rotinas asyncio.wait () método, vamos implementar estruturas de controle diferentes co-rotina, vamos olhar eles olham para ele ~ efeito diferente
de controle de fluxo linear na pluralidade de coroutine facilmente gerido através de built-in palavra-chave aguardam. Uso asyncio módulo estrutura mais complicada pode ser conseguida, pode ser realizado concorrentemente pluralidade co-rotina.
一, asyncio.wait ()
Você pode ser uma operação separada em várias partes e executado, e esperar (tarefas) pode ser usado para definir um evento para ser tarefas de interrupção (tarefas) que circulam para a tarefa de consulta, outro fundo até a conclusão da operação da coroutine acordado.
import time
import asyncio
async def taskIO_1():
print('开始运行IO任务1...')
await asyncio.sleep(2) # 假设该任务耗时2s
print('IO任务1已完成，耗时2s')
return taskIO_1.__name__
async def taskIO_2():
print('开始运行IO任务2...')
await asyncio.sleep(3) # 假设该任务耗时3s
print('IO任务2已完成，耗时3s')
return taskIO_2.__name__
async def main(): # 调用方
tasks = [taskIO_1(), taskIO_2()] # 把所有任务添加到task中
done,pending = await asyncio.wait(tasks) # 子生成器
for r in done: # done和pending都是一个任务，所以返回结果需要逐个调用result()
print('协程无序返回值：'+r.result())
if __name__ == '__main__':
start = time.time()
loop = asyncio.get_event_loop() # 创建一个事件循环对象loop
try:
loop.run_until_complete(main()) # 完成事件循环，直到最后一个任务结束
finally:
loop.close() # 结束事件循环
print('所有IO任务总耗时%.5f秒' % float(time.time()-start))
resultados da execução são as seguintes:
开始运行IO任务1...
开始运行IO任务2...
IO任务1已完成，耗时2s
IO任务2已完成，耗时3s
协程无序返回值：taskIO_2
协程无序返回值：taskIO_1
所有IO任务总耗时3.00209秒
[Explique]: wait () documentação oficial usado como segue:
done, pending = await asyncio.wait(aws)
Aqui executados AWS simultaneamente passaram (objetos awaitable), e retorna uma tupla contendo (feito, pendente) por esperam, feito indica que a lista tarefa foi concluída, enquanto se aguarda indica que a lista de tarefas não está completa.
Nota:
① só é possível quando a gerar uma lista de pendente wait () passou do tempo limite parâmetros.
② retornar o conjunto de resultados é organizado a fim de completar a tarefa, a espera ciclo de eventos (), por isso tende a ordem original das diferentes tarefas.
二, asyncio.gather ()
Se você está apenas em causa sobre o resultado de co-rotinas executadas simultaneamente coleção, você pode usar a recolher (), que retorna apenas um conjunto de resultados não só pela esperam, eo resultado é a ordem do conjunto de resultados da ordem original da tarefa recebida.
'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
import time
import asyncio
async def taskIO_1():
print('开始运行IO任务1...')
await asyncio.sleep(3) # 假设该任务耗时3s
print('IO任务1已完成，耗时3s')
return taskIO_1.__name__
async def taskIO_2():
print('开始运行IO任务2...')
await asyncio.sleep(2) # 假设该任务耗时2s
print('IO任务2已完成，耗时2s')
return taskIO_2.__name__
async def main(): # 调用方
resualts = await asyncio.gather(taskIO_1(), taskIO_2()) # 子生成器
print(resualts)
if __name__ == '__main__':
start = time.time()
loop = asyncio.get_event_loop() # 创建一个事件循环对象loop
try:
loop.run_until_complete(main()) # 完成事件循环，直到最后一个任务结束
finally:
loop.close() # 结束事件循环
print('所有IO任务总耗时%.5f秒' % float(time.time()-start))
resultados da execução são as seguintes:
开始运行IO任务2...
开始运行IO任务1...
IO任务2已完成，耗时2s
IO任务1已完成，耗时3s
['taskIO_1', 'taskIO_2']
所有IO任务总耗时3.00184秒
[Explique]: recolher () retorna um conjunto de resultados diretamente pelo aguardar a lista, podemos ver claramente a partir dos resultados, embora a tarefa 2 é concluída primeiro, mas a ordem para retornar o conjunto de resultados final é a ordem inicial da tarefa de entrada remar.
三, asyncio.as_completed ()
as_completed (tarefas) é um gerador que gerencia uma lista coroutine (aqui é as tarefas de entrada) para ser executado. Quando o chumbo conjunto de tarefas em uma tarefa for concluída, será a primeira missão para retornar os resultados esperam por palavra-chave. ordem visível e voltar a espera resultado (), como estão dispostas, a fim de completar a tarefa.
'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：579817333
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
import time
import asyncio
async def taskIO_1():
print('开始运行IO任务1...')
await asyncio.sleep(3) # 假设该任务耗时3s
print('IO任务1已完成，耗时3s')
return taskIO_1.__name__
async def taskIO_2():
print('开始运行IO任务2...')
await asyncio.sleep(2) # 假设该任务耗时2s
print('IO任务2已完成，耗时2s')
return taskIO_2.__name__
async def main(): # 调用方
tasks = [taskIO_1(), taskIO_2()] # 把所有任务添加到task中
for completed_task in asyncio.as_completed(tasks):
resualt = await completed_task # 子生成器
print('协程无序返回值：'+resualt)
if __name__ == '__main__':
start = time.time()
loop = asyncio.get_event_loop() # 创建一个事件循环对象loop
try:
loop.run_until_complete(main()) # 完成事件循环，直到最后一个任务结束
finally:
loop.close() # 结束事件循环
print('所有IO任务总耗时%.5f秒' % float(time.time()-start))
resultados da execução são as seguintes:
开始运行IO任务2...
开始运行IO任务1...
IO任务2已完成，耗时2s
协程无序返回值：taskIO_2
IO任务1已完成，耗时3s
协程无序返回值：taskIO_1
所有IO任务总耗时3.00300秒
[Explicar]: pode ser visto a partir do procedimento acima, utilizando as_completed (tarefas), e espera (tarefas) em comuns resultados de sequências de volta para completar a co-rotina de pedido, que Reunir () é justamente o oposto. A diferença é que as_completed (tarefas) pode retornar para completar os resultados em tempo real atuais, e espera (tarefas) para aguardar feito para retornar após o fim de toda a co-rotina para obter resultados.
IV Resumo
Aws consulte o seguinte: objetos awaitable. Para esperar recolha de objectos, tais como um co-rotina está à espera de uma lista de objectos que contém uma pluralidade de um co-rotina é AWS.
| asyncio | A principal passagem de parâmetros | seqüência valor de retorno | aguardar o tipo de valor de retorno | Função Tipo retornado |
|---|---|---|---|---|
| esperar() | aws | sequência completa coroutine | (Feito, pendente) com lista de tarefas duas tuplas | coroutine |
| as_completed () | aws | sequência completa coroutine | Devolver o valor original | iterator |
| reunir() | * AWS | Parâmetro passando Task Order | Retornar uma lista de valores | awaitable |
