分布式进程

分布式进程

多台机器创建进程联合执行任务

分布式进程的步骤

#分布式进程六个步骤：
1.建立队列Queue，用来进程间的通信。
2.将队列Queue进行网络共享给其他进程
3.建立对象实例，绑定端口和验证口令
4.启动对象实例进行信息传输管理
5.通过对象实例将网络队列本地化
6.分配本地化队列进行进程任务处理

在主机也就是发布任务的主机服务进程

import random
from queue import Queue
# BaseManager: 提供了不同机器之间共享数据的一种方法(ip:port)
from multiprocessing.managers import BaseManager

# 1. 创建存储任务需要的队列
task_queue = Queue()

# 2. 存储任务执行结果的队列
result_queue = Queue()


# 3. 将队列注册到网上(使得其他主机也可以访问)
BaseManager.register('get_task_queue', callable=lambda : task_queue)
BaseManager.register('get_result_queue', callable=lambda : result_queue)


# 绑定ip和端口， 并且来个暗号；
manager = BaseManager(address=('172.25.254.67', 4000), authkey=b'westos')


# 4. 启动manager对象， 开始共享队列
manager.start()
# 5. 通过网络访问共享的Queue对象;
# BaseManager.register会注册一个方法, 当调用方法时， 执行函数lambda : task_queue;
task = manager.get_task_queue()
result = manager.get_result_queue()

# 6. 往队列里面放执行任务需要的数据;
for i in range(1000):
    # 模拟有1000个数字；
    n = random.randint(1, 100)
    task.put(n)
    print("任务列表中加入任务: %d" %(n))

# 7. 从result队列中读取各个机器中任务执行的结果;
for i in range(1000):
    res = result.get()
    print("队列任务执行的result: %s" %(res))


#  8. 关闭manager对象， 取消共享的队列
manager.shutdown()

可多台任务主机连接服务主机，这里本来模拟了两个任务主机，其任务程序都是一样的，任务主机的任务进程：

import time
from multiprocessing.managers import BaseManager
# 1. 连接Master端， 获取共享的队列;ip是master端的ip， port'也是master端manager进程绑定的端口;
slave = BaseManager(address=('172.25.254.67', 4000), authkey=b'westos')

# 2. 注册队列， 获取共享的队列内容;
BaseManager.register('get_task_queue')
BaseManager.register('get_result_queue')

# 3. 连接master端;
slave.connect()

# 4. 通过网络访问共享的队列;
task = slave.get_task_queue()
result = slave.get_result_queue()

# 5. 读取管理端共享的任务， 并依次执行;
for i in range(500):
    n = task.get()
    print("slave1 运行任务 %d ** 2: " % (n))
    res = "slave1: %d ** 2 = %d" % (n, n ** 2)
    time.sleep(1)
    # 将任务的运行结果放入队列中;
    result.put(res)

print("执行结束........")

运行显示结果：

# 服务主机显示结果：
...
任务列表中加入任务: 19
任务列表中加入任务: 19
任务列表中加入任务: 25
任务列表中加入任务: 87
队列任务执行的result: slave1: 54 ** 2 = 2916
队列任务执行的result: slave1: 22 ** 2 = 484
队列任务执行的result: slave1: 89 ** 2 = 7921
队列任务执行的result: slave2: 72 ** 2 = 5184
队列任务执行的result: slave1: 12 ** 2 = 144
队列任务执行的result: slave2: 45 ** 2 = 2025
队列任务执行的result: slave1: 20 ** 2 = 400
队列任务执行的result: slave2: 19 ** 2 = 361
...


任务主机1的结果显示：
slave1 运行任务 54 ** 2: 
slave1 运行任务 22 ** 2: 
slave1 运行任务 89 ** 2: 
slave1 运行任务 12 ** 2: 

任务主机2的结果显示：
slave2 运行任务 72 ** 2: 
slave2 运行任务 45 ** 2: 
slave2 运行任务 19 ** 2: 
slave2 运行任务 27 ** 2: 
slave2 运行任务 51 ** 2: