Beispiel für die Verwendung mehrerer Python-Prozesse (Code)

Der Inhalt dieses Artikels befasst sich mit den Verwendungsbeispielen (Code) von Python-Multiprozessen. Freunde in Not können darauf verweisen.

Python-Multithreading eignet sich für IO-intensive Szenarien, aber in CPU-intensiven Szenarien können Multi-Core-CPUs nicht vollständig genutzt werden. Coroutinen sind im Wesentlichen threadbasiert und können die Vorteile von Multi-Cores nicht vollständig nutzen .

Für rechenintensive Szenarien, die die Verwendung mehrerer Prozesse erfordern, ist Pythons Multiprocessing dem Threading-Modul sehr ähnlich und unterstützt die Batch-Erstellung untergeordneter Prozesse mithilfe eines Prozesspools.

• Erstellen Sie einen einzelnen Process-Prozess (mit func)

Sie müssen nur die Process-Klasse instanziieren und die Funktion an den Zielparameter übergeben. Dies ist dem Threading-Modul sehr ähnlich, args ist der Parameter der Funktion

import os
from multiprocessing import Process

# 子进程要执行的代码
def task(name):
    print('run child process %s (%s)...' % (name, os.getpid()))

if __name__ == '__main__':
    print('parent process %s.' % os.getpid())
    p = Process(target=task, args=('test',))
    p.start()
    p.join()
    print('process end.')

• Erstellen Sie einen einzelnen Prozessprozess (mit Klasse)

Erben Sie die Process-Klasse und überschreiben Sie die Ausführungsmethode, um einen Prozess zu erstellen, der im Grunde mit dem Threading-Modul identisch ist

import multiprocessing
import os
from multiprocessing import current_process
class Worker(multiprocessing.Process):
    def run(self):
        name = current_process().name  # 获取当前进程的名称
        print(&#39;run child process <%s>  (%s)&#39; % (name, os.getpid()))

        print(&#39;In %s&#39; % self.name)
        return

if __name__ == &#39;__main__&#39;:
    print(&#39;parent process %s.&#39; % os.getpid())
    p = Worker()
    p.start()
    p.join()
    print(&#39;process end.&#39;)

　* Stoppen Sie den Prozess

terminate() beendet den untergeordneten Prozess, aber die Ressourcen des untergeordneten Prozesses können nicht freigegeben werden, was nicht empfohlen wird, da der Ausführungsstatus des untergeordneten Threads nicht klar ist Wenn es endet, besteht eine hohe Wahrscheinlichkeit, dass der untergeordnete Thread zu einem unpassenden Zeitpunkt beendet wird.

import multiprocessing
import time

def worker():
    print('starting worker')
    time.sleep(0.1)
    print('finished worker')

if __name__ == '__main__':
    p = multiprocessing.Process(target=worker)
    print('执行前:', p.is_alive())
    p.start()
    print('执行中:', p.is_alive())
    p.terminate()  # 发送停止号
    print('停止:', p.is_alive())
    p.join()
    print('等待完成:', p.is_alive())

• Mehrere Prozesse direkt erstellen

import multiprocessing

def worker(num):
    print(f'Worker:%s %s', num)
    return

if __name__ == '__main__':
    jobs = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(i,))
        jobs.append(p)
        p.start()

• Verwenden Sie den Prozesspool, um mehrere Prozesse zu erstellen

Bei Verwendung von Python für die Systemverwaltung, insbesondere beim gleichzeitigen Betrieb mehrerer Dateiverzeichnisse oder Remote Die Steuerung mehrerer Hosts und paralleler Betrieb können viel Zeit sparen. Wenn die Anzahl der zu bedienenden Objekte nicht groß ist, können Sie Process in Multiprocessing direkt verwenden, um mehrere Prozesse dynamisch zu generieren. Ein Dutzend oder so ist in Ordnung, aber wenn es Hunderte oder Tausende von Zielen gibt, wäre eine manuelle Begrenzung zu viel Wenn die Anzahl der Prozesse zu umständlich ist, kann zu diesem Zeitpunkt der Prozesspool verwendet werden.
Der Pool kann Benutzern eine bestimmte Anzahl von Prozessen zum Aufrufen bereitstellen. Wenn der Pool nicht voll ist, wird ein neuer Prozess erstellt, um die Anforderung auszuführen Wenn die Anzahl der Prozesse das angegebene Maximum erreicht hat, wartet die Anfrage, bis ein Prozess im Pool endet, und dann wird ein neuer Prozess erstellt, um ihn zu verarbeiten.

import os
import random
import time
from multiprocessing import Pool
from time import ctime


def task(name):
    print('start task %s (%s)...' % (name, os.getpid()))
    start = time.time()
    time.sleep(random.random() * 3)

    print('end task %s runs %0.2f seconds.' % (name, (time.time() - start)))


if __name__ == '__main__':
    print('parent process %s.' % os.getpid())

    p = Pool()  # 初始化进程池
    for i in range(5):
        p.apply_async(task, args=(i,))  # 追加任务 apply_async 是异步非阻塞的，就是不用等待当前进程执行完毕，随时根据系统调度来进行进程切换。

    p.close()

    p.join()  # 等待所有结果执行完毕，会等待所有子进程执行完毕，调用join()之前必须先调用close()
    print(f'all done at: {ctime()}')

Wenn Ihnen das Ausführungsergebnis jedes Prozesses am Herzen liegt, können Sie die get-Methode verwenden, die das Ergebnis zurückgibt, um es abzurufen. Der Code lautet wie folgt

import os
import random
import time
from multiprocessing import Pool, current_process
from time import ctime


def task(name):
    print('start task %s (%s)...' % (name, os.getpid()))
    start = time.time()
    time.sleep(random.random() * 3)
    print('end task %s runs %0.2f seconds.' % (name, (time.time() - start)))

    return current_process().name + 'done'

if __name__ == '__main__':
    print('parent process %s.' % os.getpid())

    result = []

    p = Pool()  # 初始化进程池
    for i in range(5):
        result.append(p.apply_async(task, args=(i,)))  # 追加任务 apply_async 是异步非阻塞的，就是不用等待当前进程执行完毕，随时根据系统调度来进行进程切换。

    p.close()

    p.join()  # 等待所有结果执行完毕

    for res in result:
        print(res.get())  # get()函数得出每个返回结果的值

    print(f'all done at: {ctime()}')

　

Das obige ist der detaillierte Inhalt vonBeispiel für die Verwendung mehrerer Python-Prozesse (Code). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!