Le module multitraitement en Python vous permet de créer et de gérer des processus, vous permettant de profiter pleinement de plusieurs processeurs sur une machine. Il vous aide à réaliser une exécution parallèle en utilisant des espaces mémoire distincts pour chaque processus, contrairement au threading où les threads partagent le même espace mémoire. Voici une liste des classes et méthodes couramment utilisées dans le module multitraitement avec de brefs exemples.
La classe Process est le cœur du module multitraitement, vous permettant de créer et d'exécuter de nouveaux processus.
from multiprocessing import Process
def print_numbers():
for i in range(5):
print(i)
p = Process(target=print_numbers)
p.start() # Starts a new process
p.join() # Waits for the process to finish
Démarre l'activité du processus.
p = Process(target=print_numbers) p.start() # Runs the target function in a separate process
Bloque le processus appelant jusqu'à ce que le processus dont la méthode join() est appelée se termine. En option, vous pouvez spécifier un délai d'attente.
p = Process(target=print_numbers) p.start() p.join(2) # Waits up to 2 seconds for the process to finish
Renvoie True si le processus est toujours en cours d'exécution.
p = Process(target=print_numbers) p.start() print(p.is_alive()) # True if the process is still running
Renvoie l'objet Process actuel représentant le processus appelant.
from multiprocessing import current_process
def print_current_process():
print(current_process())
p = Process(target=print_current_process)
p.start() # Prints the current process info
Renvoie une liste de tous les objets Processus actuellement actifs.
p1 = Process(target=print_numbers) p2 = Process(target=print_numbers) p1.start() p2.start() print(Process.active_children()) # Lists all active child processes
Renvoie le nombre de processeurs disponibles sur la machine.
from multiprocessing import cpu_count print(cpu_count()) # Returns the number of CPUs on the machine
Un objet Pool fournit un moyen pratique de paralléliser l'exécution d'une fonction sur plusieurs valeurs d'entrée. Il gère un pool de processus de travail.
from multiprocessing import Pool
def square(n):
return n * n
with Pool(4) as pool: # Pool with 4 worker processes
result = pool.map(square, [1, 2, 3, 4, 5])
print(result) # [1, 4, 9, 16, 25]
Une file d'attente est une structure de données partagée qui permet à plusieurs processus de communiquer en transmettant des données entre eux.
from multiprocessing import Process, Queue
def put_data(q):
q.put([1, 2, 3])
def get_data(q):
data = q.get()
print(data)
q = Queue()
p1 = Process(target=put_data, args=(q,))
p2 = Process(target=get_data, args=(q,))
p1.start()
p2.start()
p1.join()
p2.join()
Un verrou garantit qu'un seul processus peut accéder à une ressource partagée à la fois.
from multiprocessing import Process, Lock
lock = Lock()
def print_numbers():
with lock:
for i in range(5):
print(i)
p1 = Process(target=print_numbers)
p2 = Process(target=print_numbers)
p1.start()
p2.start()
p1.join()
p2.join()
Les objets Value et Array permettent de partager des types de données simples et des tableaux entre les processus.
from multiprocessing import Process, Value
def increment(val):
with val.get_lock():
val.value += 1
shared_val = Value('i', 0)
processes = [Process(target=increment, args=(shared_val,)) for _ in range(10)]
for p in processes:
p.start()
for p in processes:
p.join()
print(shared_val.value) # Output will be 10
Un Pipe fournit un canal de communication bidirectionnel entre deux processus.
from multiprocessing import Process, Pipe
def send_message(conn):
conn.send("Hello from child")
conn.close()
parent_conn, child_conn = Pipe()
p = Process(target=send_message, args=(child_conn,))
p.start()
print(parent_conn.recv()) # Receives data from the child process
p.join()
Un Manager vous permet de créer des objets partagés, tels que des listes et des dictionnaires, que plusieurs processus peuvent modifier simultanément.
from multiprocessing import Process, Manager
def modify_list(shared_list):
shared_list.append("New item")
with Manager() as manager:
shared_list = manager.list([1, 2, 3])
p = Process(target=modify_list, args=(shared_list,))
p.start()
p.join()
print(shared_list) # [1, 2, 3, "New item"]
Un sémaphore vous permet de contrôler l'accès à une ressource, en autorisant seulement un certain nombre de processus à y accéder à la fois.
from multiprocessing import Process, Semaphore
import time
sem = Semaphore(2) # Only 2 processes can access the resource
def limited_access():
with sem:
print("Accessing resource")
time.sleep(2)
processes = [Process(target=limited_access) for _ in range(5)]
for p in processes:
p.start()
for p in processes:
p.join()
Le module multitraitement en Python est conçu pour tirer pleinement parti de plusieurs processeurs sur une machine. De la création et de la gestion de processus à l'aide de Process au contrôle des ressources partagées avec Lock et Semaphore, en passant par la facilitation de la communication via Queue et Pipe, le module multitraitement est crucial pour la parallélisation des tâches dans les applications 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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
