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

Coroutine: A parte do código que pode ser pausada e retomada em script multithread é chamada coroutine. Coroutines trabalham cooperativamente em programa multithread. Quando uma coroutina faz uma pausa, outra coroutina pode executar.

Loop de eventos: É usado para iniciar a execução de coroutinas e lidar com operações de entrada/saída. São necessárias várias tarefas e complete -as.

Tarefa: A execução e o resultado das coroutinas são definidos pelas tarefas. Você pode atribuir várias tarefas usando a Biblioteca Asyncio e executar as tarefas de forma assíncrona.

Futuro: Ele atua como um armazenamento futuro onde o resultado de coroutines armazenará após a conclusão. Isso é útil quando qualquer coroutina exige para esperar o resultado de outra coroutina.

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

Exemplo 1: Crie uma única coroutina 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 A função é declarada para calcular a soma de uma gama específica de números. O número de número de 1 a 101 é atribuído pela tarefa com um segundo atraso. O loop do evento é declarado que será executado até que todas as tarefas do método principal sejam concluídas. Depois de calcular o valor, a função aguardará um segundo e imprimirá o resultado.

importar asyncio
ASYNC def add (start, fim, espera):
#Initialize Sum Variable
soma = 0
#Calcular a soma de todos os números
para n em range (start, fim):
soma += n
#Wait por segundos atribuídos
Aguarda Asyncio.sono (espere)
#Print O resultado
print (f'Sum de start a end é sum ')
Async def main ():
#Sign uma única tarefa
tarefa = loop.create_task (add (1.101,1))
#Run a tarefa assíncrona
Aguarda Asyncio.Espere ([tarefa])
se __name__ == '__main__':
#Declare Event Loop
Loop = Asyncio.get_event_loop ()
#Run o código até concluir todas as tarefas
laço.run_until_complete (main ())
#Fechar o ciclo
laço.fechar()

Saída:

$ python3 Async1.py

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

Exemplo 2: Crie várias coroutinas

O uso da biblioteca Asyncio será liberado quando você executará várias coroutinas simultaneamente. Crie um novo arquivo chamado Async2.py e adicione o seguinte código. Três tarefas são geradas com três faixas diferentes e valores de espera em principal() método. A primeira tarefa calculará a soma de 5 a 500000 esperando 3 segundos, a segunda tarefa calculará a soma de 2 a 300000 esperando 2 segundos e a terceira tarefa calculará a soma de 10 a 1000 esperando 1 segundos. A tarefa com baixos valores de espera será concluída no início e a tarefa com alto valor de espera será concluído finalmente.

importar asyncio
ASYNC def add (start, fim, espera):
#Initialize Sum Variable
soma = 0
#Calcular a soma de todos os números
para n em range (start, fim):
soma += n
#Wait por segundos atribuídos
Aguarda Asyncio.sono (espere)
#Print O resultado
print (f'Sum de start a end é sum ')
Async def main ():
#Assign Primeira tarefa
tarefa1 = loop.create_task (add (5.500000,3))
#Assign Segunda tarefa
Task2 = Loop.create_task (add (2.300000,2))
#Assign Terceira tarefa
tarefa3 = loop.create_task (add (10,1000,1))
#Run as tarefas de forma assíncrona
Aguarda Asyncio.Espere ([Task1, Task2, Task3])
se __name__ == '__main__':
#Declare Event Loop
Loop = Asyncio.get_event_loop ()
#Run o código até concluir todas as tarefas
laço.run_until_complete (main ())
#Fechar o ciclo
laço.fechar()

Saída:

$ python3 Async1.py

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

Exemplo 3: Coroutines com futuro

Este exemplo mostra o uso do objeto futuro da Biblioteca Asyncio. Crie um novo arquivo chamado Async3.py e adicione o seguinte código. Duas tarefas são atribuídas para o futuro neste exemplo. Mostrar mensagem A função é declarada aqui para imprimir a mensagem antes de executar a coroutina e depois de concluir a execução. A primeira tarefa esperará 2 segundos e completará o último. A segunda tarefa esperará 1 segundos e completará primeiro.

importar asyncio
ASYNC def show_message (número, espera):
#Print a mensagem
Print (f'Task número está em execução ')
#Wait por segundos atribuídos
Aguarda Asyncio.sono (espere)
Print (f'Task número está concluído ')
Async def stop_after (quando):
Aguarda Asyncio.sono (quando)
laço.parar()
Async def main ():
#Assign Primeira tarefa
Task1 = Asyncio.garantir_future (show_message (1,2))
Imprimir ('Anexo 1')
#Assign Segunda tarefa
Task2 = Asyncio.garantir_future (show_message (2,1))
Imprimir ('Anexo 2')
#Run as tarefas de forma assíncrona
Aguarda Asyncio.Espere ([Task1, Task2])
se __name__ == '__main__':
#Declare Event Loop
Loop = Asyncio.get_event_loop ()
#Run o código do método principal até concluir todas as tarefas
laço.run_until_complete (main ())

Saída:

$ python3 Async3.py

É mostrado na saída que a tarefa1 é iniciada primeiro e concluída por último, e o Task2 é iniciado posteriormente, mas concluído primeiro por um curto tempo de espera.

Conclusão

O conceito básico de programação assíncrona usando a Biblioteca Asyncio de Python é explicada aqui. Espero que você possa escrever código multithread em Python depois de praticar os exemplos deste tutorial.