मैं प्रक्रियाओं में वर्ग के सदस्यों को कैसे अपडेट कर सकता हूं? [डुप्लिकेट]
मैंने अन्य प्रश्नों की तलाश की है, और यह संयुक्त राष्ट्र का स्वीकृत उत्तर केवल वही है जो मुझे मिल सकता है कि किसी तरह इस मुद्दे को शामिल किया गया है और वास्तव में मददगार नहीं है। इसके अलावा, मुझे प्रक्रियाओं के साथ काम करने की आवश्यकता है, न कि थ्रेड्स।
इसलिए जमीन से मैंने अपना मुद्दा दिखाने के लिए एक नमूना कार्यक्रम लिखा, आपको इसे पेस्ट करने में सक्षम होना चाहिए और यह चलेगा:
import multiprocessing
import time
class Apple:
def __init__(self, color):
self.color = color
def thinkAboutApple(apple):
while True:
print(apple.color)
time.sleep(2)
my_apple = Apple("red")
new_process = multiprocessing.Process(target=thinkAboutApple, args=(my_apple,))
new_process.start()
time.sleep(4)
print("new: brown")
my_apple.color = "brown"
#so that the program doesn't exit after time.sleep(4)
while True:
pass
# actual output | # wanted output
red | red
red | red
new: brown | new: brown
red | brown
red | brown
यह मुझे बताता है कि या तो सेब एक अजीब स्थिति में है जहां एक ही समय में दो रंग हैं, या यह कि नया_प्रोसेस सेब राम में एक और स्थिति में है और मुख्य प्रक्रिया में सेब से अलग हो गया है।
तो सवाल यह है कि क्या एक ही ऐप्पल में पॉइंटर के पॉइंटर को एक ही ऐप्पल में रखने का कोई तरीका है, या सभी प्रक्रियाओं में ऐप्पल के सभी इंस्टेंस को समान रखने के लिए पाइथोनिक तरीका क्या है? क्या होगा यदि मेरे पास कई प्रक्रियाओं में समान सेब है और सेब के बिना भी अधिक प्रक्रियाएं हैं, तो मैं यह कैसे सुनिश्चित करूं कि वे हमेशा एक ही क्षेत्र में हों?
जवाब
आप एक (undocumented) से Proxy
उपयोग किए गए वर्ग के एक विशेष संस्करण को प्राप्त कर सकते हैं , जो कि आधार वर्ग के विपरीत, इसके सभी तरीकों और विशेषताओं को उजागर करता है। यह लिंक किए गए डुप्लिकेट प्रश्न के @ shtse8 के उत्तर के समान है, लेकिन मैं इसे स्पष्ट करने के लिए पोस्ट कर रहा हूं कि यह कैसे करना है।multiprocessing.BaseManager
multiprocessing.managers.NamespaceProxy
from multiprocessing import Process
from multiprocessing.managers import BaseManager, NamespaceProxy
import time
import types
class MyManager(BaseManager): pass # Avoid namespace pollution.
class Apple:
def __init__(self, color):
self.color = color
def Proxy(target):
""" Create a derived NamespaceProxy class for `target`. """
def __getattr__(self, key):
result = self._callmethod('__getattribute__', (key,))
if isinstance(result, types.MethodType):
def wrapper(*args, **kwargs):
self._callmethod(key, args)
return wrapper
return result
dic = {'types': types, '__getattr__': __getattr__}
proxy_name = target.__name__ + "Proxy"
ProxyType = type(proxy_name, (NamespaceProxy,), dic) # Create subclass.
ProxyType._exposed_ = tuple(dir(target))
return ProxyType
AppleProxy = Proxy(Apple)
def thinkAboutApple(apple):
while True:
print(f"apple.color: {apple.color}")
time.sleep(1)
if __name__ == '__main__':
MyManager.register('Apple', Apple, AppleProxy)
manager = MyManager()
manager.start()
my_apple = manager.Apple("red")
new_process = Process(target=thinkAboutApple, args=(my_apple,))
new_process.start()
time.sleep(2) # Allow other process to run a short while.
my_apple.color = "brown" # Change shared class instance.
time.sleep(2) # Allow other process to run at little while longer.
new_process.terminate()