Instance variables are not shared between processes in Python

Question content

I'm having a big problem with multiprocessing. In this case I have a

1. Main class in the main process

2. Class foo in another process

I have to change some variables inside process2 using the main process. How can I do this/? ? ?

class Main:
     def __init__(self):
          self.Foo_Instance = Foo()
          multiprocessing.Process(target=self.Foo_Instance.do_something).start()

     def Change_Foo(self):
          Foo_Instance.ImportantVar = True
    
class Foo:
     def __init__(self):
          self.ImportantVar = False

     def do_something(self):
          pass

Main_Instance = Main()
Main_Instance.Change_Foo()

Correct Answer

Each process usually has its own memory that cannot be accessed by any other process. If you want one process to be able to modify a variable that is being used by another process, the simplest solution is to create the variable in shared memory. In the following demonstration, we use the multiprocessing.value instance. To prove that main.change_foo can modify the importantvar attribute of foo, we must give foo before main.change_foo modifies it .do_something An opportunity to print out its initial value. Likewise, foo.do_something needs to wait for main.change_foo to change the value before printing out the updated value. To achieve this, we use two 'multiprocessing.event' instances:

import multiprocessing
import ctypes
import time

class main:
    def __init__(self):
        self.foo_instance = foo()
        multiprocessing.process(target=self.foo_instance.do_something).start()

    def change_foo(self):
        # wait for foo.do_something to have printed out its initial value:
        self.foo_instance.initial_print_event.wait()

        # modify the attribute (add missing self):
        self.foo_instance.importantvar.value = true

        # show that we have modified the attribute:
        self.foo_instance.changed_event.set()


class foo:
    def __init__(self):
        self.importantvar = multiprocessing.value(ctypes.c_bool, false, lock=false)
        self.initial_print_event = multiprocessing.event()
        self.changed_event = multiprocessing.event()

    def do_something(self):
        print('do_something before:', self.importantvar.value)
        # show that we have completed printing our initial value:
        self.initial_print_event.set()

        # now wait for main.change_foo to have changed our variable:
        self.changed_event.wait()

        print('do_something after:', self.importantvar.value)


# required for windows:
if __name__ == '__main__':
    main_instance = main()
    main_instance.change_foo()

Print:

do_something before: False
do_something after: True

The above is the detailed content of Instance variables are not shared between processes in Python. For more information, please follow other related articles on the PHP Chinese website!