Detaillierte Erläuterung der Multiprozess-Implementierung in Python (mit Beispielen)

Dieser Artikel bietet Ihnen eine detaillierte Erklärung der Multiprozess-Implementierung in Python (mit Beispielen). Ich hoffe, dass er Ihnen als Referenz dienen wird.

Die Fork-Funktion erstellt einen untergeordneten Prozess

Grundlegende Verwendung

Das Linux-Betriebssystem bietet eine Fork-Funktion zum Erstellen eines untergeordneter Prozess. fork() befindet sich im Betriebssystemmodul von Python.
Verwenden Sie einfach das importierte Betriebssystemmodul.

import os
os.fork()

Jedes Mal, wenn die Funktion fork() aufgerufen wird, generiert der entsprechende übergeordnete Prozess einen untergeordneten Prozess.
Zum Beispiel der folgende Code:

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

Nach der Ausführung werden 8 Prozesse generiert.

Der Rückgabewert der Funktion fork()

Der Rückgabewert der Funktion fork() für den untergeordneten Prozess ist immer 0, während der Rückgabewert für den Der übergeordnete Prozess ist die PID (Prozessnummer) des untergeordneten Prozesses.

Instanz

#!/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()}")

Ausführungsergebnis:

Prozessmodul

Importmodul

Python stellt außerdem die Multiprocessing-Bibliothek zur Verfügung, um Multithread-Programmierung für die gesamte Plattform bereitzustellen.

import multiprocessing

Einfacher Prozess

Der folgende Code ist ein einfacher Prozess:

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

Hier wird die Process-Klasse aus der Multiprocessing-Bibliothek vorgestellt.
p1 = Process(target = work, args = (num,)) erstellt einen Prozess. Das Ziel ist die Funktion zum Ausführen der Aufgabe und args sind die empfangenen Parameter, die in Form von Tupeln angegeben werden müssen.
start() startet den Prozess.
Es gibt einige Methoden für gleichzeitige Prozesse:

Join-Methode

Die Join-Methode von Process ähnelt Multithreading. Warten auf das Ende des Prozesses.
Verwendung: beitreten (Zeitüberschreitung).
Mit join() wartet das Programm auf das Ende des Prozesses, bevor es mit dem folgenden Code fortfährt.
Wenn der Timeout-Parameter hinzugefügt wird, wartet das Programm Timeout-Sekunden, bevor es mit der Ausführung des folgenden Programms fortfährt.

close-Methode

close() wird zum Schließen des Prozesses verwendet, kann jedoch den laufenden untergeordneten Prozess nicht schließen.

Prozessklasse

Sie können mehrere Prozesse implementieren, indem Sie eine Klasse erstellen:

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

Prozesspool

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

Der Aufruf der Methode „join()“ für das Pool-Objekt wartet, bis die Ausführung aller untergeordneten Prozesse abgeschlossen ist. „Close()“ muss aufgerufen werden, bevor „join()“ aufgerufen wird. Nach dem Aufruf von „close()“ können keine neuen Prozesse hinzugefügt werden.
Die Zahl in Pool(num) ist die Anzahl der Prozesse, die hinzugefügt werden sollen. Wenn die Anzahl der Prozesse nicht angegeben ist, wird standardmäßig die Anzahl der CPU-Kerne verwendet.

Prozesse sind unabhängig voneinander

Jeder Prozess in mehreren Prozessen verfügt über eine Kopie der Variablen, und die Vorgänge zwischen Prozessen beeinflussen sich nicht gegenseitig.

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)

Das endgültige Ausführungsergebnis:

Wenn Datei-E/A-Vorgänge ausgeführt werden, schreiben mehrere Prozesse in dieselbe Datei.

Queue

Durch die Verwendung von Queue im Multiprocessing können verschiedene Prozesse auf dieselben Ressourcen zugreifen.

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

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Multiprozess-Implementierung in Python (mit Beispielen). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!