Tutorial-Erklärung der Python-Mehrprozesssteuerung (mit Beispielen)

Dieser Artikel enthält ein Tutorial zur Python-Multiprozesssteuerung (mit Beispielen). Freunde in Not können darauf verweisen.

Einführung in Multiprocessing

Multiprocessing ist ein Multiprozessmodul, das mit Python geliefert wird. Es kann Prozesse in großen Stapeln generieren. Der Effekt ist besser, wenn der Server ein ist Multi-Core-CPU, ähnlich dem Threading-Modul. Im Vergleich zu Multi-Threading ist Multi-Processing aufgrund seines exklusiven Speicherplatzes stabiler und sicherer. Bei der Durchführung von Batch-Vorgängen in Betrieb und Wartung bietet Multi-Processing mehr Anwendungsszenarien

Das Multi-Processing-Paket bietet sowohl lokale als auch Remote-Paralleloperationen vermeiden effektiv die Verwendung von untergeordneten Prozessen anstelle von Threads mit globalen Interpretationssperren. Daher kann Multiprocessing die Multi-Core-Verarbeitung effektiv nutzen

Prozessklasse

In Beim Multiprocessing werden Prozesse stapelweise über Process-Klassenobjekte generiert und die start()-Methode wird verwendet, um den Prozess zu starten

1. Syntax

multiprocessing.Process(group=None,target=None,name=None,args=(),kwargs={},*)

group: 这个参数一般为空，它只是为了兼容threading.Tread
target: 这个参数就是通过run()可调用对象的方法，默认为空，表示没有方法被调用
name: 表示进程名
args: 传给target调用方法的tuple(元组)参数
kwargs: 传给target调用方法的dict(字典)参数

2. Methoden und Objekte der Process-Klasse

run()
Diese Methode ist der laufende Prozess des Prozesses und kann sein Beim Schreiben dieser Methode ist es im Allgemeinen selten,

start()
zu rekonstruieren, um den Prozess zu starten diese Methode

join([timeout])
Warten Sie, bis der Prozess beendet ist, bevor Sie fortfahren

Name
kann den Prozessnamen erhalten, mehrere Prozesse können auch denselben Namen haben

is_alive()
Gibt zurück, ob der Prozess ist noch am Leben, wahr oder falsch, Prozessüberleben bezieht sich auf den Start von start() bis zur Beendigung des untergeordneten Prozesses

Daemon
Die Markierung des Daemon-Prozesses, ein boolescher Wert, nach start(). Legen Sie diesen Wert fest, um anzugeben, ob im Hintergrund ausgeführt werden soll
Hinweis: Wenn die Ausführung im Hintergrund festgelegt ist, wird das Hintergrundprogramm nicht ausgeführt und erstellt dann einen untergeordneten Prozess

pid
Sie können die Prozess-ID erhalten

Exitcode
Der Wert wann Der untergeordnete Prozess wird beendet. Wenn der untergeordnete Prozess nicht beendet wurde, lautet der Wert „None“.

Um den Prozess zu beenden, wenn es sich um Windows handelt, verwenden Sie „terminateprocess()“. Die Methode, die den Prozess beendet und beendet hat, wird nicht ausgeführt Das Folgende ist ein einfaches Beispiel:

#-*- coding:utf8 -*- 
import multiprocessing
import time

def work(x):
   time.sleep(1)
   print time.ctime(),'这是子进程[{0}]...'.format(x)

if __name__ == '__main__':
    for i in range(5):
        p = multiprocessing.Process(target=work,args=(i,))
        print '启动进程数:{0}'.format(i)
        p.start()
        p.deamon = True

Natürlich kann auch die ID jedes Prozesses angezeigt werden

#-*- coding:utf8 -*- 
import multiprocessing
import time
import os

def work(x):
   time.sleep(1)
   ppid = os.getppid()
   pid  = os.getpid()
   print time.ctime(),'这是子进程[{0},父进程:{1},子进程:{2}]...'.format(x,ppid,pid)

if __name__ == '__main__':
    for i in range(5):
        p = multiprocessing.Process(target=work,args=(i,))
        print '启动进程数:{0}'.format(i)
        p.start()
        p.deamon = True

Aber tatsächlich Bei der Verwendung handelt es sich nicht nur um Parallelität. Da die Serverressourcen begrenzt sind, ist es auch schwierig, 30 Aufgaben zu erhalten Stellen Sie eine konsistente Ausführungszeit gleichzeitiger Prozessaufgaben sicher, insbesondere bei Aufgaben, die Zeit erfordern. Es können 5 Aufgaben gleichzeitig ausgeführt werden, von denen 3 noch abgeschlossen sind und von denen 2 noch viel Zeit in Anspruch nehmen Die Ausführung dieser beiden Prozesse ist abgeschlossen, bevor mit der Ausführung nachfolgender Aufgaben fortgefahren wird. Daher gibt es hier Verwendungsszenarien. Sie können die Process-Methode in Kombination mit einigen Multiprocessing-Paketen und -Klassen verwenden und Kommunikation

1. Die Warteschlangenklasse

ähnelt Queue.Queue, die mit Python geliefert wird, und wird hauptsächlich in der Syntax für kleinere Warteschlangen verwendet :

multiprocessing.Queue([maxsize])

Klassenmethode:

qsize()

Gibt die ungefähre Größe der Warteschlange zurück, da mehrere Prozesse oder Threads die Warteschlange belegt haben, die Daten also nicht unbedingt korrekt

empty()

Bestimmen Sie, ob die Warteschlange leer ist. Wenn ja, geben Sie True zurück, andernfalls False
full()

Bestimmen Sie, ob die Warteschlange voll ist. Wenn ja, geben Sie True zurück, andernfalls False
put(obj[, block[, timeout]])

Legen Sie das Objekt in die Warteschlange, der optionale Parameterblock ist True und das Timeout ist None
get()

Objekt aus der Warteschlange entfernen

#-*- coding:utf8 -*-
from multiprocessing import Process, Queue

def f(q):
    q.put([42,None,'hi'])

if __name__ == '__main__':
    q = Queue()
    p = Process(target=f, args=(q,))
    p.start()
    print q.get()  #打印内容: [42,None,'hi']
    p.join()

two , Die Pipe-Klasse

pipe()-Funktion gibt ein Paar von Objektverbindungen zurück, die Nachrichten zwischen Prozessen übertragen können und beim Drucken einiger Protokolle und der Prozesssteuerung nützlich sind. Das Pip()-Objekt gibt zwei Objekte zurück Zwei Kanäle. Jedes Verbindungsobjekt verfügt über die Methoden send() und recv(). Es ist zu beachten, dass zwei oder mehr Prozesse gleichzeitig zu Datenverwechslungen führen können bedeckt. Wenn außerdem eine der beiden zurückgegebenen Verbindungen send()-Daten enthält, kann die andere nur Daten über recv() empfangen.

#-*- coding:utf8 -*-
from multiprocessing import Process, Pipe
import time
def f(conn,i):
    print '[{0}]已经执行到子进程:{1}'.format(time.ctime(),i)
    time.sleep(1)
    w = "[{0}]hi,this is :{1}".format(time.ctime(),i)
    conn.send(w)
    conn.close()

if __name__ == '__main__':
    reader = []
    parent_conn, child_conn = Pipe()
    for i in range(4):
        p = Process(target=f, args=(child_conn,i))
        p.start()
        reader.append(parent_conn)
        p.deamon=True

    # 等待所有子进程跑完
    time.sleep(3)
    print '\n[{0}]下面打印child_conn向parent_conn传输的信息:'.format(time.ctime())
    for i in reader:
        print i.recv()

Die Ausgabe lautet:

三、Value,Array

在进行并发编程时，应尽量避免使用共享状态，因为多进程同时修改数据会导致数据破坏。但如果确实需要在多进程间共享数据，multiprocessing也提供了方法Value、Array

from multiprocessing import Process, Value, Array

def f(n, a):
    n.value = 3.1415927
    for i in range(len(a)):
        a[i] = -a[i]

if __name__ == '__main__':
    num = Value('d',0.0)
    arr = Array('i', range(10))

    p = Process(target=f, args=(num, arr))
    p.start()
    p.join()

    print num.value
    print arr[:]

*print
3.1415927
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]*

四、Manager进程管理模块

Manager类管理进程使用得较多，它返回对象可以操控子进程，并且支持很多类型的操作，如: list, dict, Namespace、lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value, Array，因此使用Manager基本上就够了

from multiprocessing import Process, Manager

def f(d, l):
    d[1] = '1'
    d['2'] = 2
    d[0.25] = None
    l.reverse()

if __name__ == '__main__':
    with Manager() as manager:
        d = manager.dict()
        l = manager.list(range(10))

        p = Process(target=f, args=(d, l))
        p.start()
        p.join() #等待进程结束后往下执行
        print d,'\n',l

输出：
{0.25: None, 1: '1', '2': 2}
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
可以看到，跟共享数据一样的效果，大部分管理进程的方法都集成到了Manager()模块了

五、对多进程控制的应用实例

    #-*- coding:utf8 -*-
    from multiprocessing import Process, Queue
    import time
    
    def work(pname,q):
        time.sleep(1)
        print_some = "{0}|this is process: {1}".format(time.ctime(),pname)
        print print_some
        q.put(pname)
    
    if __name__ == '__main__':
        p_manag_num = 2  # 进程并发控制数量2
        # 并发的进程名
        q_process = ['process_1','process_2','process_3','process_4','process_5']
        q_a = Queue() # 将进程名放入队列
        q_b = Queue() # 将q_a的进程名放往q_b进程,由子进程完成
    
        for i in q_process:
            q_a.put(i)
    
        p_list = [] # 完成的进程队列
        while not q_a.empty():
            if len(p_list) <p>执行结果:</p><p><img src="https://img.php.cn//upload/image/167/872/710/1542261551928622.png" title="1542261551928622.png" alt="Tutorial-Erklärung der Python-Mehrprozesssteuerung (mit Beispielen)"></p>

Das obige ist der detaillierte Inhalt vonTutorial-Erklärung der Python-Mehrprozesssteuerung (mit Beispielen). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!