Programmation serveur Python : introduction au module de concurrence intégré de Python

Programmation serveur Python : Introduction au module de concurrence intégré de Python

Avec la popularité d'Internet et des appareils mobiles, les applications réseau nécessitent de plus en plus de programmes serveur hautes performances. En tant que langage de programmation efficace et évolutif, Python joue un rôle de plus en plus important dans la programmation réseau. Cet article se concentrera sur l'introduction du module de concurrence intégré à Python pour aider les lecteurs à mieux comprendre le mécanisme de concurrence dans la programmation serveur Python.

1. Threads

Python dispose d'un module de threading intégré, qui prend en charge la programmation multithread. En créant des threads, plusieurs tâches peuvent être exécutées simultanément dans un programme. Le code suivant montre comment utiliser le module de threading pour créer et démarrer des threads :

import threading

def worker(num):
    """线程执行的函数"""
    print('Worker %d is starting...' % num)

threads = []
for i in range(5):
    t = threading.Thread(target=worker, args=(i,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

Dans le code ci-dessus, 5 threads sont créés en appelant la fonction threading.Thread(), et la fonction d'exécution de chaque thread est désignée comme worker( ). Enfin, démarrez ces threads en appelant la méthode start(), puis appelez la méthode join() pour attendre que le thread termine son exécution.

Il convient de noter que les threads en Python sont implémentés sur la base des threads natifs du système d'exploitation (c'est-à-dire un modèle de thread un-à-un). Sur certains systèmes d'exploitation, les threads peuvent consommer de grandes quantités de ressources système, même lorsqu'ils sont inactifs. Par conséquent, lors de l'utilisation de threads, le nombre de threads doit être raisonnablement utilisé en fonction de la situation spécifique pour éviter le gaspillage de ressources.

2. Process

Python dispose d'un module multitraitement intégré, qui prend en charge la concurrence et la communication inter-processus. En utilisant le module multitraitement, vous pouvez exécuter plusieurs processus simultanément dans un programme afin de mieux utiliser les performances des processeurs multicœurs. Le code suivant montre comment utiliser le module multiprocessing pour créer et démarrer un processus :

import multiprocessing

def worker(num):
    """进程执行的函数"""
    print('Worker %d is starting...' % num)

processes = []
for i in range(5):
    p = multiprocessing.Process(target=worker, args=(i,))
    processes.append(p)
    p.start()

for p in processes:
    p.join()

Dans le code ci-dessus, 5 processus sont créés en appelant la fonction multiprocessing.Process(), et la fonction d'exécution de chaque processus est désignée comme travailleur (). Enfin, démarrez ces processus en appelant la méthode start(), puis appelez la méthode join() pour attendre la fin de l'exécution du processus.

Il convient de noter que la communication inter-processus doit être implémentée à l'aide de Queue, Pipe et d'autres méthodes. Ces méthodes peuvent être trouvées dans le module multitraitement.

3. Coroutine

Coroutine est un mécanisme de concurrence léger qui peut réaliser l'exécution de commutation de plusieurs sous-programmes en un seul processus. Python dispose d'un module asyncio intégré, qui prend en charge la simultanéité des coroutines. En utilisant le module asyncio, des E/S asynchrones et une programmation réseau efficace peuvent être obtenues. Le code suivant montre comment utiliser le module asyncio pour implémenter des coroutines :

import asyncio

async def worker(num):
    """协程执行的函数"""
    print('Worker %d is starting...' % num)
    await asyncio.sleep(1)
    print('Worker %d is finished.' % num)

async def main():
    """协程调度器"""
    tasks = [asyncio.create_task(worker(i)) for i in range(5)]
    await asyncio.gather(*tasks)

asyncio.run(main())

Dans le code ci-dessus, async est utilisé pour définir une fonction de coroutine worker(), et async est utilisé pour définir un planificateur de coroutines main(), via asyncio. La fonction create_task() crée 5 tâches coroutine et utilise la fonction asyncio.gather() pour une exécution simultanée. Enfin, le planificateur de coroutines est exécuté via la fonction asyncio.run().

Il convient de noter que les programmes coroutine sont extrêmement flexibles et efficaces, mais nécessitent des capacités de programmation élevées et des connaissances professionnelles.

4. Résumé

Les trois modules de concurrence intégrés de Python (threading, multiprocessing, asyncio) peuvent fournir différents mécanismes de concurrence dans différents scénarios. Lors de l'écriture d'un programme serveur, vous devez choisir des modules de concurrence et des mécanismes de concurrence appropriés en fonction des besoins réels pour améliorer les performances et la fiabilité du programme.

Il convient de noter que Python n'est pas un langage de programmation serveur spécialisé, donc lors de l'écriture de programmes serveur hautes performances, d'autres facteurs doivent être pris en compte, tels que le nombre de connexions, la concurrence, le temps de réponse aux demandes, etc. En sélectionnant rationnellement les modules de concurrence et en concevant des algorithmes efficaces, les performances du programme serveur peuvent être optimisées et une bonne expérience utilisateur peut être fournie.

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!