Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· openaiHugging Face Suzhen/CodeChat

使用python3中mutiprocessing中manager模块实现简易的分布式计算,代码如何写?

  1. User

    使用python3中mutiprocessing中manager模块实现简易的分布式计算,代码如何写?

  2. Assistant

    以下是使用python3中mutiprocessing中manager模块实现简易的分布式计算的示例代码:

    from multiprocessing import Process, Manager
     
    def worker(num, data):
        data[num] = num * 2  # 模拟计算任务,将结果存入共享dict中
     
    if __name__ == '__main__':
        with Manager() as manager:  # 创建共享dict
            data = manager.dict()
            processes = []
            for i in range(10):  # 创建10个进程
                p = Process(target=worker, args=(i, data))
                processes.append(p)
                p.start()
            for p in processes:
                p.join()
            print(data.values())  # 输出结果
    

    代码中使用Manager创建共享dict,并创建10个子进程来执行模拟计算任务,每个子进程将计算结果存入共享dict中,最后主进程输出dict的values即为计算结果。

  3. User

    使用python3中mutiprocessing中manager模块实现简易多主机的分布式计算,代码如何写?

  4. Assistant

    以下是使用python3中mutiprocessing中manager模块实现简易多主机的分布式计算的示例代码:

    1. server端代码:
    from multiprocessing.managers import BaseManager
    
    # 定义任务队列
    task_queue = []
    # 定义结果队列
    result_queue = []
    
    class QueueManager(BaseManager):
        pass
    
    def get_task_queue():
        global task_queue
        return task_queue
    
    def get_result_queue():
        global result_queue
        return result_queue
    
    if __name__ == '__main__':
        # 注册任务队列和结果队列
        QueueManager.register('get_task_queue', callable=get_task_queue)
        QueueManager.register('get_result_queue', callable=get_result_queue)
        # 绑定端口5000,设置验证码'abc'
        manager = QueueManager(address=('0.0.0.0', 5000), authkey=b'abc')
        # 启动服务
        server = manager.get_server()
        server.serve_forever()
    
    1. client端代码:
    from multiprocessing.managers import BaseManager
    from multiprocessing import Process
    
    # 定义任务队列
    task_queue = []
    # 定义结果队列
    result_queue = []
    
    class QueueManager(BaseManager):
        pass
    
    def get_task_queue():
        global task_queue
        return task_queue
    
    def get_result_queue():
        global result_queue
        return result_queue
    
    if __name__ == '__main__':
        # 注册任务队列和结果队列
        QueueManager.register('get_task_queue', callable=get_task_queue)
        QueueManager.register('get_result_queue', callable=get_result_queue)
        # 连接server端口5000,设置验证码'abc'
        manager = QueueManager(address=('server_ip', 5000), authkey=b'abc')
        # 连接服务
        manager.connect()
        
        # 获取任务队列和结果队列
        task_queue = manager.get_task_queue()
        result_queue = manager.get_result_queue()
        
        # 定义任务处理函数
        def worker(num):
            task = task_queue.get()
            task_queue.task_done()
            result = task * 2  # 处理任务
            result_queue.put(result)  # 将结果存入共享队列
            
        # 创建10个进程来处理任务
        processes = []
        for i in range(10):
            p = Process(target=worker, args=(i,))
            processes.append(p)
            p.start()
        
        # 往任务队列中添加任务
        for i in range(10):
            task_queue.put(i)
            
        # 等待任务处理完成
        task_queue.join()
        
        # 输出结果队列中的值
        while not result_queue.empty():
            print(result_queue.get())
    

    client端代码中连接到server端口为5000的服务,同时将任务处理函数worker放到10个进程中处理任务,每个进程从任务队列中获取任务,完成任务后将结果存入结果队列,最后输出结果队列中的所有值。server端代码启动服务并监听端口,client端连接后通过获取共享队列来传递任务和结果。

  5. User

    如何实现任务执行完毕服务端关闭

  6. Assistant

    实现任务执行完毕服务端关闭可以在server端实现一个关闭服务的接口,在所有任务都执行完毕后通过这个接口关闭server。

    1. server端代码:
    from multiprocessing.managers import BaseManager
    
    # 定义任务队列
    task_queue = []
    # 定义结果队列
    result_queue = []
    
    class QueueManager(BaseManager):
        pass
    
    def get_task_queue():
        global task_queue
        return task_queue
    
    def get_result_queue():
        global result_queue
        return result_queue
    
    if __name__ == '__main__':
        # 注册任务队列和结果队列
        QueueManager.register('get_task_queue', callable=get_task_queue)
        QueueManager.register('get_result_queue', callable=get_result_queue)
        # 绑定端口5000,设置验证码'abc'
        manager = QueueManager(address=('0.0.0.0', 5000), authkey=b'abc')
        # 启动服务
        server = manager.get_server()
        server.serve_forever()
        
        # 任务全部执行完毕,关闭server
        manager.shutdown()
    
    1. client端代码:
    from multiprocessing.managers import BaseManager
    from multiprocessing import Process
    
    # 定义任务队列
    task_queue = []
    # 定义结果队列
    result_queue = []
    
    class QueueManager(BaseManager):
        pass
    
    def get_task_queue():
        global task_queue
        return task_queue
    
    def get_result_queue():
        global result_queue
        return result_queue
    
    if __name__ == '__main__':
        # 注册任务队列和结果队列
        QueueManager.register('get_task_queue', callable=get_task_queue)
        QueueManager.register('get_result_queue', callable=get_result_queue)
        # 连接server端口5000,设置验证码'abc'
        manager = QueueManager(address=('server_ip', 5000), authkey=b'abc')
        # 连接服务
        manager.connect()
        
        # 获取任务队列和结果队列
        task_queue = manager.get_task_queue()
        result_queue = manager.get_result_queue()
        
        # 定义任务处理函数
        def worker(num):
            task = task_queue.get()
            task_queue.task_done()
            result = task * 2  # 处理任务
            result_queue.put(result)  # 将结果存入共享队列
            
        # 创建10个进程来处理任务
        processes = []
        for i in range(10):
            p = Process(target=worker, args=(i,))
            processes.append(p)
            p.start()
        
        # 往任务队列中添加任务
        for i in range(10):
            task_queue.put(i)
            
        # 等待任务处理完成
        task_queue.join()
        
        # 关闭server
        manager.shutdown()
    

    client端代码中在所有任务处理完成后调用manager的shutdown方法来关闭server。server端在所有任务全部执行完毕后也会调用同样的shutdown方法来关闭服务。