बहुत सारे शोध और परीक्षण के बाद, मैंने पाया कि "प्रबंधक" गैर-जटिल ऑब्जेक्ट स्तर में यह कार्य करता है।
नीचे दिया गया कोड दिखाता है कि ऑब्जेक्ट inst प्रक्रियाओं के बीच साझा किया गया है, जिसका अर्थ है inst जब बच्चे की प्रक्रिया में परिवर्तन होता है तो बाहर बदल दिया जाता है।
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class SimpleClass(object):
def __init__(self):
self.var = 0
def set(self, value):
self.var = value
def get(self):
return self.var
def change_obj_value(obj):
obj.set(100)
if __name__ == '__main__':
BaseManager.register('SimpleClass', SimpleClass)
manager = BaseManager()
manager.start()
inst = manager.SimpleClass()
p = Process(target=change_obj_value, args=[inst])
p.start()
p.join()
print inst # <__main__.SimpleClass object at 0x10cf82350>
print inst.get() # 100
ठीक है, इसके बाद के संस्करण कोड पर्याप्त अगर आप केवल सरल वस्तुओं साझा करने की आवश्यकता है।
कोई जटिल क्यों नहीं? क्योंकि यह विफल हो सकता है अगर आपके वस्तु (ऑब्जेक्ट के अंदर वस्तु) नीडिंत है:
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
class GetSetter(object):
def __init__(self):
self.var = None
def set(self, value):
self.var = value
def get(self):
return self.var
class ChildClass(GetSetter):
pass
class ParentClass(GetSetter):
def __init__(self):
self.child = ChildClass()
GetSetter.__init__(self)
def getChild(self):
return self.child
def change_obj_value(obj):
obj.set(100)
obj.getChild().set(100)
if __name__ == '__main__':
BaseManager.register('ParentClass', ParentClass)
manager = BaseManager()
manager.start()
inst2 = manager.ParentClass()
p2 = Process(target=change_obj_value, args=[inst2])
p2.start()
p2.join()
print inst2 # <__main__.ParentClass object at 0x10cf82350>
print inst2.getChild() # <__main__.ChildClass object at 0x10cf6dc50>
print inst2.get() # 100
#good!
print inst2.getChild().get() # None
#bad! you need to register child class too but there's almost no way to do it
#even if you did register child class, you may get PicklingError :)
मुझे लगता है कि क्योंकि Manager सिर्फ एक candybar पाइप की तरह निम्न स्तर के संचार उपकरण के शीर्ष पर निर्माण है इस व्यवहार का मुख्य कारण यह है /कतार।
तो, यह दृष्टिकोण मल्टीप्रोसेसिंग मामले के लिए अच्छी तरह से अनुशंसित नहीं है। यह हमेशा बेहतर है अगर आप की तरह Redis कतार या Redis या उच्च स्तर के उपकरण की तरह लॉक/सेमाफोर/पाइप/कतार निम्न स्तर के उपकरणों का उपयोग कर सकते हैं प्रकाशित/जटिल उपयोग के मामले (केवल मेरी सिफारिश lol) के लिए सदस्यता ले रहा है।
संबंधित: http://stackoverflow.com/questions/659865/python-multiprocessing-sharing-a-large-read-only-object-between-processes – tokland