Explication détaillée de l'implémentation multi-processus en Python (avec exemples)

Le contenu de cet article est une explication détaillée de l'implémentation du multi-processus en Python (avec des exemples). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

La fonction fork crée un processus enfant

Utilisation de base

Le système d'exploitation Linux fournit une fonction fork pour créer un processus enfant. fork() est situé dans le module os de Python.
Utilisez simplement le module OS importé.

import os
os.fork()

Chaque fois que la fonction fork() est appelée, le processus parent correspondant générera un processus enfant.
Par exemple, le code suivant :

import os
os.fork()
os.fork()
os.fork()

Après exécution, 8 processus seront générés.

La valeur de retour de la fonction fork()

La valeur de retour de la fonction fork() pour le processus enfant est toujours 0, tandis que la valeur de retour pour le processus enfant le processus parent est le pid du processus enfant (numéro de processus).

Instance

#!/usr/bin/env python
import os
import time

rt = os.fork()

if rt == 0:
    print(f"The child process is {os.getpid()} . His father is {os.getppid()}")  # os.getpid()获取当前进程进程号，os.getppid()获取当前进程的父进程号
    time.sleep(5)
else:
    print(f"The father process is {os.getpid()} . His father is {os.getppid()}")
    time.sleep(5)

print(f"Now the process is {os.getpid()} . His father is {os.getppid()}")

Résultat de l'exécution :

Module Processus

Module d'importation

Python fournit également la bibliothèque multitraitement pour fournir une programmation multithread pour l'ensemble de la plateforme.

import multiprocessing

Processus simple

Le code suivant est un processus simple :

from multiprocessing import Process


def work(num):
    for i in range(10):
        num += 1
    print(num)
    return 0


def main():
    num = 1
    p1 = Process(target = work, args = (num,))
    p1.start()


if __name__ == '__main__':
    main()

Ici, la classe Process est introduite à partir de la bibliothèque multitraitement.
p1 = Process(target = work, args = (num,)) crée un processus. La cible est la fonction pour effectuer la tâche, et args sont les paramètres reçus, qui doivent être donnés sous forme de tuples.
start() démarre le processus.
Il existe quelques méthodes pour les processus simultanés :

méthode de jointure

La méthode de jointure de Process est similaire au multi-threading. En attendant la fin du processus.
Utilisation : join(timeout).
En utilisant join(), le programme attendra la fin du processus avant de continuer avec le code suivant.
Si le paramètre timeout est ajouté, le programme attendra les secondes d'expiration avant de continuer à exécuter le programme suivant.

méthode close

close() est utilisée pour fermer le processus, mais elle ne peut pas fermer le processus enfant en cours d'exécution.

Classe de processus

Vous pouvez implémenter plusieurs processus en créant des classes :

from multiprocessing import Process
import time


class My_Process(Process):

    def __init__(self,num):
        Process.__init__(self)
        self.num = num

    def run(self):
        time.sleep(2)
        print(self.num)


def main():
    for i in range(10):
        p = My_Process(i)
        p.start()


if __name__ == '__main__':
    main()

Pool de processus

from multiprocessing import Pool
import time


def target(num):
    time.sleep(2)
    print(num)


def main():
    pool = Pool(3)
    for i in range(3):
        pool.apply_async(target,(i,))
    pool.close()
    pool.join()
    print('Finish!!!')


if __name__ == '__main__':
    main()

L'appel de la méthode join() sur l'objet Pool attendra que tous les processus enfants terminent leur exécution. Close() doit être appelé avant d'appeler join(). Après avoir appelé close(), de nouveaux processus ne peuvent pas être ajoutés.
Le num dans Pool(num) est le nombre de processus à y ajouter. Si le nombre de processus n'est pas spécifié, la valeur par défaut est le nombre de cœurs de processeur.

Les processus sont indépendants les uns des autres

Chaque processus dans plusieurs processus a une copie des variables et les opérations entre les processus ne s'affectent pas les unes les autres.

import multiprocessing
import time

zero = 0

def change_zero():
    global zero
    for i in range(3):
        zero = zero + 1
        print(multiprocessing.current_process().name, zero)

if __name__ == '__main__':
    p1 = multiprocessing.Process(target = change_zero)
    p2 = multiprocessing.Process(target = change_zero)
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print(zero)

Résultat final de l'exécution :

Si l'opération d'E/S sur le fichier est effectuée, plusieurs processus écriront dans le même milieu de fichier .

Queue

L'utilisation de Queue en multitraitement permet à différents processus d'accéder aux mêmes ressources.

from multiprocessing import Process, Queue
def addone(q):
    q.put(1)
def addtwo(q):
    q.put(2)
if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=addone, args = (q, ))
    p2 = Process(target=addtwo, args = (q, ))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print(q.get())
    print(q.get())

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!