Unable to update a class variable with multiprocessing

Question

I'm making a GUI application that tracks time spent on each foreground window. I attempted to do this with a loop for every process being monitored as such:

class processes(object):
    def __init__(self, name, pid):
        self.name = name
        self.pid = pid
        self.time_spent = 0
        self.time_active = 0
        p1 = multiprocessing.Process(target=self.loop, args=())
        p1.start()

    def loop(self):
        t = 0
        start_time = time.time()

        while True:

            #While the process is running, check if foreground window (window currently being used) is the same as the process

            h_wnd = user32.GetForegroundWindow()
            pid = wintypes.DWORD()
            user32.GetWindowThreadProcessId(h_wnd, ctypes.byref(pid))
            p = psutil.Process(pid.value)

            name = str(p.name())
            name2 = str(self.name)

            if name2 == name:
                t = time.time() - start_time

            #Log the total time the user spent using the window
            self.time_active += t
            self.time_spent = time.perf_counter()
            time.sleep(2)

    def get_time(self):
        print("{:.2f}".format(self.time_active) + " name: " + self.name)

I select the process I want in the gui and find it by its name in a list. Once found I call the function get_time() that's supposed to print how long the selected process has been in the foreground.

def display_time(Lb2):
    for s in Lb2.curselection():
        for e in process_list:
            if Lb2.get(s) == e.name:
                e.get_time()

The problem is time_active is 0 every time I print it.

I've debugged the program and can tell it's somewhat working (not perfectly, it still records time while the program is not on the foreground) and updating the variable inside the loop. However, when it comes to printing it out the value remains as 0. I think I'm having trouble understanding multiprocessing if anyone could clear up the confusion

Answer 1

The simplest solution was offered by @TheLizzard, i.e. just use threading instead of multiprocessing:

import threading
...
        #p1 = multiprocessing.Process(target=self.loop, args=())
        p1 = threading.Thread(target=self.loop, args=())

But that doesn't explain why creating a process instead did not work. What happened was that your process.__init__ code first created several attributes such as self.time_active, self.time_spent, etc. This code is executing in the main process. But when you execute the following two statements ...

        p1 = multiprocessing.Process(target=self.loop, args=())
        p1.start()

... the process object that was created must now be serialized/deserialized to the new address space in which the new Process instance you just created must run. Consequently, in the loop method when you execute a statement such as self.time_active += t, you are updating the instance of self.time_active that "lives" in the address space of the sub-process. But code that prints out the value of self.time_active is executing in the main process's address space and is therefore printing out only the original value of that attribute.

If you had to use multiprocessing because your loop method was CPU-intensive and you needed the parallelism with other processes, then the solution would be to create self.time_active and self.time_spent in shared memory so that both the main process and the sub-process would be accessing the same, shared attributes:

class processes(object):
    def __init__(self, name, pid):
        self.name = name
        self.pid = pid
        # Create shared floating point values:
        self.time_spent = multiprocessing.Value('f', 0)
        self.time_active = multiprocessing.Value('f', 0)
        ...

    def loop(self):
        ...
        self.time_active.value += t
        self.time_spent.value = time.perf_counter()
        ...

    def get_time(self):
        print("{:.2f}".format(self.time_active.value) + " name: " + self.name)