Un guide rapide du module multitraitement Python avec des exemples

Introduction

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.

1. Processus

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

2. démarrer()

Démarre l'activité du processus.

p = Process(target=print_numbers)
p.start()  # Runs the target function in a separate process

3. rejoindre([timeout])

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

4. est_vivant()

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

5. processus_actuel()

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

6. enfants_actifs()

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

7. cpu_count()

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

8. Piscine

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]

9. File d'attente

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()

10. Verrouiller

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()

11. Valeur et tableau

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

12. Tuyau

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()

13. Gestionnaire

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"]

14. Sémaphore

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()

Conclusion

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!