Multiprocessing Global Variable Updates Not Returned to Parent

How to update global variable in python multiprocessing

Each process is updating its global variable, as you can see in the output. Else they would have shown "idx = 0". It's a complete other story if you want to share data between those processes, and obtain "idx = 1, 2, 3". See https://docs.python.org/3/library/multiprocessing.html#sharing-state-between-processes .

Global variable not updated in python while using multiprocessing

I think it is because this is multiprocess, not multithread. the main process and the new process does not share a same global variable. So the new process has the copy of the main process when x is [], and after created, main process change x's value, but it does not change to new process's x.

if change the code to this :

from multiprocessing import Pool
x = []

def func(a):
    print(x,a)

def main():
    a = [1,2,3,4,5]
    global x
    x = [1,2,3,4]
    pool = Pool(1)
    ans = pool.map(func,a)
    print(x)

and the ouput will be what you want.
Notice the pool = Pool(1) 's position

python multiprocessing child process cannot access to global variable

When you spawn a process using multiprocessing, your new process gets a copy of the state at the time of spawning.

If you want to communicate data between your parent process or other sibling processes, you can do so using shared variables or a server process that handles shared objects. For details, see sharing-state-between-processes

If you instead use threading, the individual threads all run in the same context, sharing all global variables. So you can access all global variables in all threads and the main loop without having to do anything special.

Both, threading and multiprocessing, have their advantages and disadvantages, but this is not the place to discuss these.

Python Multiprocessing: Variable only changes inside the function even though there is a global statement

You can try to print ids of the 'switch's in your code, and you can find they are different. (In other words, they don't share memory) Global variable doesn't work as usual in multiprocess.

And these links provide much infomation you need.

How to update global variable in python multiprocessing

Python: How to modify a global variable in a function using pprocess

multiprocessing global variable updates not returned to parent

You can replace the corresponding part of your code using the following. It should work.

def check():
    print(switch.value)
    print(id(switch))
    while True:
        while needToCheck == True:
            # global switch
            if keyboard.is_pressed(startKey):
                if switch.value == 0:
                    switch.value = 1
                    time.sleep(0.5)
                    continue
                if switch.value == 1:
                    switch.value = 0
                    time.sleep(0.7)

def move():
    # global switch
    print("switch inside of move: ", switch.value)    #equals "None" always
    while True:
        while switch.value == 1:    #switch == None so it doesn't work :C
            for _ in range(10):
                # print("pressinA")
                keyboard.press("a")
                time.sleep(0.5)
        time.sleep(0.1)
        # print(id(switch))

needToCheck = True

def running_shared():
    # consider lock if you need
    return switch.value

def set_global(args):
    global switch
    switch = args

if __name__ == "__main__":
    freeze_support()
    switch = Value('b', 0)
    print(id(switch))
    with concurrent.futures.ProcessPoolExecutor(initializer=set_global, initargs=(switch,)) as executor:
        fMove = executor.submit(move)
        fCheck = executor.submit(check)
        futures = [fMove , fCheck]
        results = [x.result() for x in futures]

How are parent process global variables copied to sub-processes in python multiprocessing

Copy-on-write does one virtual memory page at a time. As long as your changes are within a single 4096-byte page, you'll only pay for that one page. When you modify a column, your changes are spread across many, many pages. We Python programmers aren't used to worrying about the layout in physical memory, but that's the issue here.

Question 1: If you pass the dataset as a parameter, then Python has to make a copy to transfer it over. The parameter passing mechanism doesn't use copy-on-write, partly because the reference counting stuff would be confused. When you create it as a global before things start, there's a solid reference, so the multiprocessing code can make copy-on-write happen.

---

Related Topics