Exemple d'utilisation multi-processus Python (code)

Le contenu de cet article concerne les exemples d'utilisation (code) du multi-processus Python. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Le multithreading Python convient aux scénarios gourmands en E/S, mais dans les scénarios gourmands en CPU, les processeurs multicœurs ne peuvent pas être pleinement utilisés. Les coroutines sont essentiellement basées sur des threads et ne peuvent pas exploiter pleinement les avantages du multicœur. .

Pour les scénarios gourmands en calcul qui nécessitent l'utilisation de plusieurs processus, le multitraitement de Python est très similaire au module de threading et prend en charge la création par lots de processus enfants à l'aide d'un pool de processus.

• Créer un seul processus Process (en utilisant func)

Il vous suffit d'instancier la classe Process et de transmettre la fonction au paramètre cible. C'est le même que le module de threading Très similaire, args est le paramètre de la fonction

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.')

• Créer un processus unique (en utilisant la classe)

Héritez la classe Process et remplacez la méthode run pour créer un processus, qui est fondamentalement le même que le module de thread

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

　* Arrêter le processus

terminate() termine le processus enfant, mais les ressources du processus enfant ne peuvent pas être libérées. Ceci n'est pas recommandé car l'état d'exécution de l'enfant. le fil n'est pas clair quand il se termine, et il y a de fortes chances que le fil enfant ne soit pas libéré. ​​Le bon moment est terminé.

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

• Créez directement plusieurs processus

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

• Utiliser le pool de processus pour créer plusieurs processus

Lors de l'utilisation de Python pour la gestion du système, en particulier lors de l'exécution de plusieurs processus en même temps Fichier répertoire ou le contrôle à distance de plusieurs hôtes, les opérations parallèles peuvent faire gagner beaucoup de temps. Lorsque le nombre d'objets à exploiter n'est pas important, vous pouvez utiliser directement Process en multitraitement pour générer dynamiquement plusieurs processus, une douzaine suffisent, mais s'il y a des centaines ou des milliers de cibles, ce serait trop de limiter manuellement. le nombre de processus. S'il est trop lourd, le pool de processus peut être utilisé à ce moment-là.
Le pool peut fournir un nombre spécifié de processus que les utilisateurs peuvent appeler. Lorsqu'une nouvelle demande est soumise au pool, si le pool n'est pas plein, un nouveau processus sera créé pour exécuter la demande, mais si le pool est rempli ; Si le nombre de processus a atteint le maximum spécifié, la requête attendra la fin d'un processus dans le pool, puis un nouveau processus sera créé pour le gérer.

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

Si vous vous souciez du résultat de l'exécution de chaque processus, vous pouvez utiliser la méthode get qui renvoie le résultat pour l'obtenir. suit

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

　

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!