Gemeinsame globale Variable zwischen zwei Prozessen

Question

Ich versuche, zwei while Schleifen gleichzeitig in zwei separaten Prozessen auszuführen, wobei der erste eine globale Variable ändert, auf der der andere Prozess eine Entscheidung trifft.

Mein Problem ist, die globale Variable wird nicht vor dem ersten Prozess geändert, so dass der zweite Prozess nicht richtig darauf reagiert.

Dies ist mein Code:

flag = [False] 
def loop1(): 
    x = 0 
    while (x<10): 
    x = x + 1 
    read = input("Enter 0 or 1") 
    if read == 0: 
     flag[0] = False 
    else: 
     flag[0] = True 
def loop2(): 
    z = 0 
    while (z<100): 
    z = z + 1 
    if flag[0] == False: 
     # do something 
    else: 
     # do other thing 
    time.sleep(1) 
if __name__ == '__main__': 
    Process(target = loop1).start() 
    Process(target = loop2).start() 

Answer 1

Prozesse Zustand nicht teilen. Sie müssen eine gemeinsam genutzte Warteschlange wie von multiprocessing.Queue verwenden, das Warteschlangenobjekt beiden Prozessen als Argument übergeben und die Flag-Variable über die Warteschlange weiterleiten.

Alternativ können Sie threading anstelle von multiprocessing und Threads verwenden, die den Adressraum eines Prozesses teilen und die gleiche Variable (Verweis auf a) verwenden können.

Es gibt Vor-und Nachteile für beide Ansätze, eine Suche auf Threading vs Multiprocessing auf SO für Referenzen.

Im threading Fall das Flag Objekt muß an ein Objekt gebunden werden, um alle hervorgebrachten Fäden enthält, die es zu benutzen sind, zum Beispiel in einer Klasse:

from __future__ import print_function 
from threading import Thread 
import time 


class State(object): 

    def __init__(self): 
     self.flag = False 
     self.consumer_thread = Thread(target=self.check_flag) 
     self.consumer_thread.daemon = True 
     self.consumer_thread.start() 

    def read_input(self): 
     while True: 
      _read = input() 
      if _read == 0: 
       self.flag = False 
      else: 
       self.flag = True 
      time.sleep(1) 

    def check_flag(self): 
     while True: 
      if self.flag is True: 
       print("Is true") 
       # do stuff 
      time.sleep(1) 

if __name__ == "__main__": 
    state = State() 
    state.read_input() 

beiden Threads (Haupt-Thread + Verbraucher thread) bezieht sich auf das gleiche Objekt, self.flag, und teilt den self, dh den Adressraum des Klassenobjekts.