无法在Python中使用多重处理来更改嵌套对象中的数据

Question

我正在编写一个大程序作为个人项目，其中我有嵌套对象。例如，世界包含多个环境，每个环境包含多个人。我想做的是，我试图将这些人的特征从人物类返回到环境类，再返回到世界类，然后返回到主程序以显示所述结果。我正在使用多重处理来运行每个 People 对象，其中的特征会主动变化。

所附代码是问题的较小版本。

Type1

生成

Type2

，其中

Type2

更改其值，然后

Type1

值根据

Type2

更改而更改，但

Type1

实例不会检测到

Type2

中的更改。我尝试使用锁、管理器、值、队列和同步管理器（全部来自多处理），但似乎都不起作用。我是否遗漏了一些明显的东西？或者是否有不同的首选程序结构来实现我想做的事情？

我的预期输出是根据

Type1

和

Type2

中的

change()

函数将其特定数据类型值更改为

Type1Type2

Answer 1

import multiprocessing
import time


class Type1:
    def __init__(self) -> None:
        self.array =[]
        self.dict = {}
        self.text = ""
        self.number = 0
        self.process_dict = {}
        self.type2_dict = {}
        self.num = 0
    
    def start(self):
            new_type = Type2()
            p = multiprocessing.Process(target=new_type.change)
            self.process_dict[f"type2{self.num}"] = p
            self.type2_dict[f"type2{self.num}"] = new_type
            self.num += 1
            p.start()
        
    def stop(self):
        while len(self.process_dict) > 0:
            _, process = self.process_dict.popitem()
            process.terminate()
            process.join()

    
    def change(self):
        self.array, self.dict, self.text, self.number = self.type2_dict[f"type2{self.num-1}"].get_data()
            
    def print(self):
        print(self.array)
        print(self.dict)
        print(self.text)
        print(self.number)
        print(self.process_dict)
        
        
        
        
class Type2:
    def __init__(self) -> None:
        self.array =[]
        self.dict = {}
        self.text = "Hello"
        self.number = 0
    
    def change(self):
        while True:
            self.array = [6,7,8,9,10]
            self.dict = {"d":4,"e":5,"f":6}
            self.text = "Goodbye"
            self.number += 1
            print("Type2 changed")
        
    def get_data(self):
        return self.array, self.dict, self.text, self.number
        
        
if __name__ == "__main__":
    t = Type1()
    t.start()
    time.sleep(2)
    print("\n\nType1 After Start:")
    t.change()
    t.print()
    t.stop()
    print("\n\nType1 After Finish:")
    t.print()
    print("Type1 stopped")

，您可以在主线程中共享多个管理器变量，并在主线程不结束的情况下在进程内访问它们，所以我在第二个进程中使用

multiprocessing.Manager()

主线不掉。process2.join()

在示例中，process0 更新管理器变量，每 0.01 添加 +1，而 process2 只会每 1 秒通知控制台一次更新，其结果是：

import multiprocessing
import time


def worker(shared_var, update_var):
    while True:
        # Simulate some work
        if update_var:
            # Send data to the main process through the queue
            current_value = shared_var.value
            new_value = current_value + 1
            shared_var.value = new_value
            time.sleep(0.01)
        else:
            current_value = shared_var.value
            print("Main Process:", current_value)
            time.sleep(1)
                        
        

if __name__ == "__main__":
    # Create a multiprocessing queue
    manager = multiprocessing.Manager()
    
    shared_var = manager.Value('i', 0)

    # Create a multiprocessing process
    process = multiprocessing.Process(target=worker, args=(shared_var, True))
    process.start()
    
    process2 = multiprocessing.Process(target=worker, args=(shared_var, False))
    process2.start()
    process2.join()

进程间互不中断，以主线程为桥梁进行通信。