A biblioteca Asyncio é introduzida no python 3.4 para executar programas simultâneos de thread único. Esta biblioteca é mais popular do que outras bibliotecas e frameworks por sua velocidade impressionante e vários usos. Esta biblioteca é usada em python para criar, executar e estruturar corrotinas e lidar com várias tarefas simultaneamente sem fazer as tarefas em paralelo. As principais partes desta biblioteca são definidas abaixo:

Corrotina: A parte do código que pode ser pausada e retomada em um script multi-thread é chamada de co-rotina. co-rotinas trabalham cooperativamente em um programa multi-threaded. Quando uma co-rotina pausa, então outra co-rotina pode executar.

Loop de eventos: É usado para iniciar a execução de co-rotinas e lidar com operações de entrada / saída. Leva várias tarefas e as conclui.

Tarefa: A execução e o resultado das corrotinas são definidos pelas tarefas. Você pode atribuir vários números de tarefas usando a biblioteca assíncrona e executar as tarefas de forma assíncrona.

Futuro: Ele atua como um armazenamento futuro onde o resultado das co-rotinas será armazenado após a conclusão. Isso é útil quando qualquer co-rotina requer esperar pelo resultado de outra co-rotina.

Como você pode implementar os conceitos acima da biblioteca asyncio é mostrado neste tutorial usando alguns exemplos simples.

Exemplo-1: Crie uma única co-rotina com uma única tarefa

Crie um arquivo chamado async1.py e adicione o seguinte código. a biblioteca asyncio é importada para usar as funções desta biblioteca. adicionar função é declarada para calcular a soma de um determinado intervalo de números. O intervalo de números de 1 a 101 é atribuído pela tarefa com um segundo de atraso. O loop de eventos é declarado que irá rodar até que todas as tarefas do método principal sejam concluídas. Após calcular o valor, a função irá aguardar um segundo e imprimir o resultado.

importar assíncio
async def add (start, end, wait):
#Initialize sum variable
soma = 0
#Calcule a soma de todos os números
para n no intervalo (início, fim):
soma + = n
#Aguarde os segundos atribuídos
aguardar assíncio.dormir (espere)
#Imprima o resultado
imprimir (f'Sum de início a fim é soma ')
assíncrono def main ():
# Atribua uma única tarefa
tarefa = loop.create_task (add (1.101,1))
#Execute a tarefa de forma assíncrona
aguardar assíncio.esperar ([tarefa])
if __name__ == '__main__':
#Declare evento loop
loop = asyncio.get_event_loop ()
# Execute o código até completar todas as tarefas
ciclo.run_until_complete (main ())
#Feche o ciclo
ciclo.perto()

Resultado:

$ python3 async1.py

A saída mostra a soma de 1 a 101, que é 5050.

Exemplo 2: Criar várias corrotinas

O uso da biblioteca asyncio será liberado quando você executar várias corrotinas simultaneamente. Crie um novo arquivo chamado assíncrono2.py e adicione o seguinte código. Três tarefas são geradas com três intervalos diferentes e valores de espera em a Principal() método. A primeira tarefa irá calcular a soma de 5 a 500000 esperando 3 segundos, a segunda tarefa irá calcular a soma de 2 a 300000 esperando 2 segundos e a terceira tarefa irá calcular a soma de 10 a 1000 esperando 1 segundo. A tarefa com baixo valor de espera será concluída primeiro e a tarefa com alto valor de espera será concluída finalmente.

importar assíncio
async def add (start, end, wait):
#Initialize sum variable
soma = 0
#Calcule a soma de todos os números
para n no intervalo (início, fim):
soma + = n
#Aguarde os segundos atribuídos
aguardar assíncio.dormir (espere)
#Imprima o resultado
imprimir (f'Sum de início a fim é soma ')
assíncrono def main ():
#Atribuir primeira tarefa
tarefa1 = loop.create_task (add (5,500000,3))
# Atribuir segunda tarefa
tarefa2 = loop.create_task (add (2.300000,2))
# Atribuir terceira tarefa
task3 = loop.create_task (add (10,1000,1))
#Execute as tarefas de forma assíncrona
aguardar assíncio.esperar ([tarefa1, tarefa2, tarefa3])
if __name__ == '__main__':
#Declare evento loop
loop = asyncio.get_event_loop ()
# Execute o código até completar todas as tarefas
ciclo.run_until_complete (main ())
#Feche o ciclo
ciclo.perto()

Resultado:

$ python3 async1.py

A saída mostra que a tarefa3 foi concluída primeiro porque o tempo de espera dessa tarefa foi de apenas 1 segundo e a tarefa1 foi concluída por último porque o tempo de espera dessa tarefa foi de 3 segundos.

Exemplo-3: corrotinas com futuro

Este exemplo mostra o uso do futuro objeto da biblioteca assíncio. Crie um novo arquivo chamado async3.py e adicione o seguinte código. Duas tarefas são atribuídas para futuro neste exemplo. Mostrar mensagem função é declarada aqui para imprimir a mensagem antes de executar a co-rotina e após completar a execução. A primeira tarefa esperará 2 segundos e será concluída por último. A segunda tarefa aguardará 1 segundo e será concluída primeiro.

importar assíncio
assíncrono def show_message (número, aguarde):
# Imprima a mensagem
imprimir (f'Task number is running ')
#Aguarde os segundos atribuídos
aguardar assíncio.dormir (espere)
imprimir (f'Tarefa número está concluída ')
assíncrono def stop_after (quando):
aguardar assíncio.dormir (quando)
ciclo.Pare()
assíncrono def main ():
# Atribuir primeira tarefa
tarefa1 = assíncio.garantir_futuro (show_message (1,2))
imprimir ('Agenda 1')
# Atribuir segunda tarefa
tarefa2 = assíncio.garantir_futuro (show_message (2,1))
imprimir ('Agenda 2')
#Execute as tarefas de forma assíncrona
aguardar assíncio.esperar ([tarefa1, tarefa2])
if __name__ == '__main__':
#Declare evento loop
loop = asyncio.get_event_loop ()
# Execute o código do método principal até completar todas as tarefas
ciclo.run_until_complete (main ())

Resultado:

$ python3 async3.py

É mostrado na saída que a tarefa1 é iniciada primeiro e concluída por último, e a tarefa2 é iniciada mais tarde, mas concluída primeiro por um curto tempo de espera.

Conclusão

O conceito básico de programação assíncrona usando a biblioteca assíncrona de python é explicado aqui. Espero que você consiga escrever código multithread em python depois de praticar os exemplos deste tutorial.