मैं प्रक्रियाओं में वर्ग के सदस्यों को कैसे अपडेट कर सकता हूं? [डुप्लिकेट]

Dec 26 2020

मैंने अन्य प्रश्नों की तलाश की है, और यह संयुक्त राष्ट्र का स्वीकृत उत्तर केवल वही है जो मुझे मिल सकता है कि किसी तरह इस मुद्दे को शामिल किया गया है और वास्तव में मददगार नहीं है। इसके अलावा, मुझे प्रक्रियाओं के साथ काम करने की आवश्यकता है, न कि थ्रेड्स।

इसलिए जमीन से मैंने अपना मुद्दा दिखाने के लिए एक नमूना कार्यक्रम लिखा, आपको इसे पेस्ट करने में सक्षम होना चाहिए और यह चलेगा:

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

यह मुझे बताता है कि या तो सेब एक अजीब स्थिति में है जहां एक ही समय में दो रंग हैं, या यह कि नया_प्रोसेस सेब राम में एक और स्थिति में है और मुख्य प्रक्रिया में सेब से अलग हो गया है।

तो सवाल यह है कि क्या एक ही ऐप्पल में पॉइंटर के पॉइंटर को एक ही ऐप्पल में रखने का कोई तरीका है, या सभी प्रक्रियाओं में ऐप्पल के सभी इंस्टेंस को समान रखने के लिए पाइथोनिक तरीका क्या है? क्या होगा यदि मेरे पास कई प्रक्रियाओं में समान सेब है और सेब के बिना भी अधिक प्रक्रियाएं हैं, तो मैं यह कैसे सुनिश्चित करूं कि वे हमेशा एक ही क्षेत्र में हों?

जवाब

2 martineau Dec 27 2020 at 21:28

आप एक (undocumented) से Proxyउपयोग किए गए वर्ग के एक विशेष संस्करण को प्राप्त कर सकते हैं , जो कि आधार वर्ग के विपरीत, इसके सभी तरीकों और विशेषताओं को उजागर करता है। यह लिंक किए गए डुप्लिकेट प्रश्न के @ shtse8 के उत्तर के समान है, लेकिन मैं इसे स्पष्ट करने के लिए पोस्ट कर रहा हूं कि यह कैसे करना है।multiprocessing.BaseManagermultiprocessing.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()