Un article pour vous aider à comprendre l'interface de processus distribué de Python

1. Introduction

Parmi Thread et Process, Process doit être préféré car Process est plus stable et Process peut être distribué sur plusieurs machines, tandis que Thread ne peut être distribué qu'à plusieurs CPU de la même machine au maximum. .

Le module multitraitement de Python prend non seulement en charge plusieurs processus, mais le sous-module managers prend également en charge la distribution de plusieurs processus sur plusieurs machines. Vous pouvez écrire un processus de service en tant que planificateur pour distribuer des tâches à plusieurs autres processus et vous appuyer sur la communication réseau pour la gestion.

2. Analyse de cas

Lorsque vous créez un programme d'exploration, récupérez toutes les images d'un site Web. Si vous utilisez plusieurs processus, un processus est généralement responsable de récupérer l'adresse du lien de l'image et de mettre l'adresse du lien. dans Dans la file d'attente, un autre processus est chargé de récupérer l'adresse du lien dans la file d'attente pour la télécharger et la stocker localement.

Comment l'implémenter à l'aide d'un processus distribué ?

Le processus sur une machine est responsable de la récupération de l'adresse du lien, et les processus sur d'autres machines sont responsables de son stockage. Le principal problème rencontré est d'exposer la file d'attente au réseau afin que d'autres processus machine puissent y accéder. Le processus distribué encapsule ce processus. Ce processus peut être appelé la mise en réseau des files d'attente locales.

Exemple :

1.py

from multiprocessing.managers import BaseManager
from multiprocessing import freeze_support, Queue
# 任务个数
task_number = 10


# 收发队列
task_quue = Queue(task_number)
result_queue = Queue(task_number)


def get_task():
    return task_quue


def get_result():
    return result_queue
# 创建类似的queueManager
class QueueManager(BaseManager):
    pass


def win_run():
    # 注册在网络上，callable 关联了Queue 对象
    # 将Queue对象在网络中暴露
    # window下绑定调用接口不能直接使用lambda，所以只能先定义函数再绑定
    QueueManager.register('get_task_queue', callable=get_task)
    QueueManager.register('get_result_queue', callable=get_result)
    # 绑定端口和设置验证口令
    manager = QueueManager(address=('127.0.0.1', 8001), authkey='qiye'.encode())
    # 启动管理，监听信息通道
    manager.start()


    try:
        # 通过网络获取任务队列和结果队列
        task = manager.get_task_queue()
        result = manager.get_result_queue()


        # 添加任务
        for url in ["ImageUrl_" + str(i) for i in range(10)]:
            print('url is %s' % url)
            task.put(url)
            
        print('try get result')
        for i in range(10):
            print('result is %s' % result.get(timeout=10))


    except:
        print('Manager error')
    finally:
        manager.shutdown()


if __name__ == '__main__':
    freeze_support()
    win_run()

Connectez-vous au serveur, le port et le mot de passe de vérification doivent être conservés exactement les mêmes que ceux du processus du serveur. Obtenez la file d'attente du réseau, effectuez la localisation, obtenez la tâche. de la file d'attente des tâches et écrivez le résultat dans la file d'attente

2.py

#coding:utf-8
import time
from multiprocessing.managers import BaseManager
# 创建类似的Manager:
class Manager(BaseManager):
    pass
#使用QueueManager注册获取Queue的方法名称
Manager.register('get_task_queue')
Manager.register('get_result_queue')
#连接到服务器:
server_addr = '127.0.0.1'
print('Connect to server %s...' % server_addr)
# 端口和验证口令注意保持与服务进程设置的完全一致:
m = Manager(address=(server_addr, 8001), authkey='qiye')
# 从网络连接:
m.connect()
#获取Queue的对象:
task = m.get_task_queue()
result = m.get_result_queue()
#从task队列取任务,并把结果写入result队列:
while(not task.empty()):
        image_url = task.get(True,timeout=5)
        print('run task download %s...' % image_url)
        time.sleep(1)
        result.put('%s--->success'%image_url)
#结束:
print('worker exit.')

Le processus de tâche doit se connecter au processus de service via le réseau, l'adresse IP du processus de service doit donc être spécifiée.

Les résultats d'exécution sont les suivants :

Obtenez l'adresse de l'image et transmettez l'adresse à 2.py.

Recevez l'adresse transmise par 1.py, téléchargez l'image et la console affiche les résultats de l'exploration.

3. Résumé

Cet article est basé sur les bases de Python. L'interface de processus distribué de Python est simple et bien encapsulée. Elle convient aux environnements où des tâches lourdes doivent être distribuées sur plusieurs machines. . En expliquant que le rôle de Queue est de livrer des tâches et de recevoir des résultats.

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!