Comment exécuter deux fonctions asynchrones pour toujours en Python

Les fonctions asynchrones, également appelées coroutines, sont des fonctions qui peuvent être suspendues et reprises pendant l'exécution. En Python, le module asyncio fournit un cadre puissant pour écrire du code simultané à l'aide de coroutines, qui sont des fonctions spéciales qui peuvent être suspendues et reprises. Dans cet article, nous explorerons comment exécuter deux fonctions asynchrones pour toujours en utilisant asyncio en Python.

Fonction asynchrone

Les fonctions asynchrones, également appelées coroutines, sont des fonctions qui peuvent être suspendues et reprises pendant l'exécution. Ils permettent l'exécution simultanée de code sans bloquer le thread principal, permettant une utilisation efficace des ressources système.

Pour définir une fonction asynchrone en Python, nous utilisons le mot-clé async avant l'instruction def. Dans une fonction asynchrone, nous pouvons utiliser le mot-clé wait pour suspendre l'exécution et attendre la fin d'une autre fonction asynchrone ou coroutine.

Méthode 1 - Utilisation du module asyncio

Le module asyncio en Python fournit un cadre pour écrire du code simultané monothread à l'aide de coroutines, multiplexer l'accès aux E/S via des sockets et d'autres ressources, exécuter des clients et des serveurs réseau et d'autres opérations connexes. Cela nous permet d'écrire du code asynchrone de manière structurée et organisée.

Grammaire

Here, the asyncio.get_event_loop() function is used to retrieve the current event loop or create a new one if none exists.

Exemple

Dans l'exemple de fonction 1 ci-dessous, nous avons une boucle infinie qui imprime "Fonction 1", puis s'arrête pendant 1 seconde en utilisant wait asyncio.sleep(1). De même, function2 a une boucle infinie qui imprime « Function 2 » et fait une pause de 2 secondes. En appelant asyncio.gather(function1(), function2()) dans la fonction principale, nous demandons à la boucle d'événements d'exécuter les deux fonctions simultanément. La fonction asyncio.gather est responsable de la planification et de l'exécution de ces deux fonctions de manière entrelacée. Lorsque nous exécutons le script Python, la boucle d'événements s'exécute indéfiniment, exécutant à plusieurs reprises function1 et function2. La sortie démontre ce comportement, avec des messages des deux fonctions imprimés de manière entrelacée en fonction de leurs intervalles de temps respectifs.

import asyncio

async def function1():
    while True:
        print("Function 1")
        await asyncio.sleep(1)  # Pause execution for 1 second

async def function2():
    while True:
        print("Function 2")
        await asyncio.sleep(2)  # Pause execution for 2 seconds

async def main():
    await asyncio.gather(function1(), function2())

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

Sortie

Function 1
Function 2
Function 1
Function 2
Function 1
Function 1
Function 2
Function 1
Function 1
.
.
.

Méthode 1 : Utiliser des fils

Les threads sont légers et permettent d'exécuter plusieurs tâches simultanément au sein d'un seul processus. Dans cette méthode, nous utiliserons le module thread pour exécuter deux fonctions asynchrones pour toujours.

Grammaire

thread1 = threading.Thread(target=async_function1)

Exemple

Dans l'exemple ci-dessous, nous avons deux fonctions asynchrones : async_function1 et async_function2.

• async_function1 utilise time.sleep(1) pour imprimer "Async function 1" chaque seconde.

• async_function2 utilise time.sleep(2) pour imprimer "Async function 2" toutes les deux secondes.

Nous créons deux threads, thread1 et thread2, respectivement pour async_function1 et async_function2. La classe Thread du module thread est utilisée pour créer et gérer des threads. Ensuite, nous démarrons deux threads en utilisant la méthode start(). Cela démarre l'exécution de la fonction asynchrone dans un thread séparé, leur permettant de s'exécuter simultanément.

import threading
import time

def async_function1():
    while True:
        print("Async function 1")
        time.sleep(1)

def async_function2():
    while True:
        print("Async function 2")
        time.sleep(2)

thread1 = threading.Thread(target=async_function1)
thread2 = threading.Thread(target=async_function2)

thread1.start()
thread2.start()

while True:
    pass

Sortie

La sortie de cet exemple imprimera en continu "Fonction Async 1" toutes les secondes et "Fonction Async 2" toutes les deux secondes. Ce code démarre deux threads, chacun exécutant sa propre fonction asynchrone. Le thread principal est maintenu en vie grâce à une boucle infinie pour permettre aux autres threads de s'exécuter indéfiniment.

Async function 1
Async function 1
Async function 2
Async function 1
Async function 1
Async function 2
Async function 1
Async function 1
Async function 2

Méthode 3 - Utilisation du sous-processus

Les sous-processus sont des processus indépendants qui peuvent être créés et gérés dans des programmes Python. Dans cette méthode, nous utiliserons le module de sous-processus pour exécuter deux fonctions asynchrones pour toujours.

Grammaire

subprocess.Popen(args, bufsize=-1, executable=None)

Ici,

• args (obligatoire) : Ce paramètre spécifie la commande à exécuter. Il peut s'agir d'une chaîne ou d'une séquence de chaînes.

• bufsize : Ce paramètre représente la taille du tampon utilisée pour les opérations d'E/S. La valeur par défaut est -1, ce qui signifie utiliser la taille de tampon par défaut du système.

• bufsize : Ce paramètre représente la taille du tampon utilisée pour les opérations d'E/S. La valeur par défaut est -1, ce qui signifie utiliser la taille de tampon par défaut du système.

Exemple

Dans cet exemple, nous avons deux fonctions asynchrones identiques : async_function1 et async_function2.

• async_function1 utilise time.sleep(1) pour imprimer "Async function 1" chaque seconde.

• async_function2 utilise time.sleep(2) pour imprimer "Async function 2" toutes les deux secondes.

Nous utilisons la classe subprocess.Popen dans le module subprocess pour créer des sous-processus au lieu de threads. Chaque processus enfant est créé en exécutant un processus Python distinct qui exécute la fonction asynchrone correspondante. Le sous-processus est créé à l'aide du constructeur subprocess.Popen et nous transmettons la commande Python pour exécuter la fonction requise. Par exemple, ['python', '-c', 'from module import async_function1; async_function1()'] exécute async_function1 à partir d'un processus Python distinct.

import subprocess
import time

def async_function1():
    while True:
        print("Async function 1")
        time.sleep(1)

def async_function2():
    while True:
        print("Async function 2")
        time.sleep(2)

subprocess1 = subprocess.Popen(['python', '-c', 'from module import async_function1; async_function1()'])
subprocess2 = subprocess.Popen(['python', '-c', 'from module import async_function2; async_function2()'])

while True:
    pass

Sortie

La sortie de cet exemple imprimera en continu "Fonction Async 1" toutes les secondes et "Fonction Async 2" toutes les deux secondes. Ce code crée deux processus enfants, chacun exécutant sa propre fonction asynchrone. Le processus principal est maintenu en vie via une boucle infinie pour permettre aux processus enfants de s'exécuter indéfiniment.

Async function 1
Async function 1
Async function 2
Async function 1
Async function 1
Async function 2
Async function 1
Async function 1
Async function 2

结论

在本文中，我们讨论了如何使用 Python 中的 asyncio 模块在 Python 中永久运行两个异步函数。使用 asyncio 进行异步编程为编写高性能和响应式 Python 应用程序开辟了新的可能性。通过利用异步函数和事件循环，您可以利用并发的力量并有效地管理多个任务。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!