Wie teile ich Daten zwischen mehreren Prozessen in Python aus?

Verwenden Sie Multiprocessing.queue, um Daten zwischen mehreren Prozessen zu übergeben, die für Szenarien geeignet sind, in denen mehrere Hersteller und Verbraucher vorhanden sind. 2. Verwenden Sie Multiprocessing.Pipe, um eine bidirektionale Hochgeschwindigkeitskommunikation zwischen zwei Prozessen zu erreichen, jedoch nur für Zweipunktverbindungen; 3. Verwenden Sie Wert und Array, um einfache Datentypen im gemeinsamen Speicher zu speichern, und müssen mit Sperre verwendet werden, um Rennbedingungen zu vermeiden. 4. Verwenden Sie den Manager, um komplexe Datenstrukturen wie Listen und Wörterbücher auszutauschen, die sehr flexibel sind, aber eine geringe Leistung aufweisen und für Szenarien mit komplexen gemeinsamen Zuständen geeignet sind. Geeignete Methoden sollten basierend auf Datengröße, Leistungsanforderungen und Komplexität ausgewählt werden. Warteschlange und Manager eignen sich am besten für Anfänger.

Das Teilen von Daten zwischen mehreren Prozessen in Python ist nicht so einfach wie bei Threads, da jeder Prozess seinen eigenen Speicherplatz hat. Das multiprocessing von Python bietet jedoch mehrere Tools, um Daten über Prozesse hinweg sicherzustellen. Hier sind die häufigsten und effektivsten Methoden:

1. Verwenden Sie multiprocessing.Queue

Queue ist eine Thread- und Prozess-Safe-FIFO-Datenstruktur (First-in-, First-Out), mit der Sie Nachrichten oder Daten zwischen den Prozessen übergeben können.

 Multiprozessierung als MP importieren

Def Produzent (Warteschlange):
    für i in Reichweite (5):
        queue.put (f "item {i}")

Def Consumer (Warteschlange):
    während nicht queue.eMpty ():
        item = queue.get ()
        print (f "konsumiert: {item}")

Wenn __name__ == "__main__":
    queue = mp.queue ()

    p1 = mp.Process (Target = Produzent, Args = (Warteschlange,))
    p2 = mp.Process (target = Verbraucher, args = (Warteschlange,))

    p1.start ()
    p1.join ()

    p2.Start ()
    p2.join ()

Hinweis: queue.empty() ist aufgrund von Rennbedingungen nicht 100% zuverlässig. In der Praxis ist es besser, Sentinel -Werte (wie None ) zu verwenden, um die Fertigstellung zu signalisieren.

2. Verwenden Sie multiprocessing.Pipe

Pipe erstellt einen wechselseitigen Kommunikationskanal zwischen zwei Prozessen. Es ist schneller als Queue , verbindet aber nur zwei Endpunkte.

 Multiprozessierung als MP importieren

Def Sender (Conn):
    Conn.Send ("Hallo vom Absender!")
    conn.close ()

Def Receiver (Conn):
    msg = conn.recv ()
    print (f "empfangen: {msg}")
    conn.close ()

Wenn __name__ == "__main__":
    parent_conn, child_conn = mp.pipe ()

    p1 = mp.Process (target = sender, args = (child_conn,))
    p2 = mp.process (target = receiver, args = (parent_conn,))

    p1.start ()
    p2.Start ()

    p1.join ()
    p2.join ()

Verwenden Sie Pipe , wenn Sie eine schnelle und direkte Kommunikation zwischen zwei Prozessen benötigen.

3. Shared Memory: Value und Array

Für einfache Daten wie Zahlen oder Arrays können Sie gemeinsam genutzte Speicherobjekte verwenden, die durch mehrere Prozesse geändert werden können.

Value für einzelne Variablen:

 Multiprozessierung als MP importieren

definitiv (Zähler):
    für _ im Bereich (10000):
        counter.Value = 1

Wenn __name__ == "__main__":
    counter = mp.value ('i', 0) # 'i' = Integer

    proceses = [mp.process (target = Increment, args = (counter,)) für _ im Bereich (4)]

    Für P in Prozessen:
        P.Start ()
    Für P in Prozessen:
        P.Join ()

    print (f "endgültiger Zählerwert: {counter.value}"))

Ohne ordnungsgemäße Synchronisation kann dies noch Rassenbedingungen haben. Verwenden Sie Sperren zum Schutz der gemeinsamen Werte.

Mit Schloss:

 Def -Inkrement (Zähler, Schloss):
    für _ im Bereich (10000):
        mit Schloss:
            counter.Value = 1

Wenn __name__ == "__main__":
    counter = mp.value ('i', 0)
    lock = mp.lock ()

    proceses = [mp.process (target = Increment, args = (counter, lock)) für _ im Bereich (4)]
    Für P in Prozessen:
        P.Start ()
    Für P in Prozessen:
        P.Join ()

    print (f "endgültiger Zählerwert: {counter.value}"))

Array für gemeinsame Arrays:

 Def modify_array (arr):
    für i im Bereich (Len (arr)):
        arr [i] *= 2

Wenn __name__ == "__main__":
    Shared_arr = mp.Array ('I', [1, 2, 3, 4, 5])

    p = mp.process (target = modify_array, args = (shared_arr,))
    P.Start ()
    P.Join ()

    print (f "modifiziertes Array: {list (shared_arr)}"))

4. Verwenden Sie Manager() für komplexe Daten

Manager bietet eine Möglichkeit, gemeinsame Python -Objekte (Listen, Diktate usw.) zu erstellen, die sicher über Prozesse hinweg bewegt werden können. Es führt einen separaten Serverprozess aus, um die Daten zu verwalten.

 Multiprozessierung als MP importieren

Def modify_data (d, lst):
    d ['Schlüssel'] = 'Wert' '
    Lst.Append ('Artikel')

Wenn __name__ == "__main__":
    Manager = MP.Manager ()
    Shared_dict = Manager.dict ()
    Shared_List = Manager.List ()

    P = MP.Process (target = modify_data, args = (shared_dict, shared_list))
    P.Start ()
    P.Join ()

    print (f "dict: {dict (shared_dict)}")
    print (f "liste: {list (shared_list)}"))

Vorteile: Unterstützt komplexe Datentypen.
Nachteile: Langsamer als Queue oder gemeinsamer Speicher, da Daten serialisiert und über ein Rohr gesendet werden.

Zusammenfassung: Welche Methode zu verwenden?

• Queue : Beste zum sicheren Daten zwischen mehreren Prozessen sicher. Verwenden Sie, wenn Bestellungen wichtig sind oder mehrere Hersteller/Verbraucher haben.
• Pipe : Schnelle, wechselseitige Kommunikation zwischen zwei Prozessen.
• Value / Array : Effizient für die gemeinsame Nutzung einfacher numerischer Daten über gemeinsamer Speicher. Verwenden Sie mit Lock , wenn mehrere Prozesse schreiben.
• Manager : Am flexibelsten, unterstützt jedes Python -Objekt, aber langsamer. Gut für Prototypen oder komplexen gemeinsamen Zustand.

Wählen Sie die Methode basierend auf Ihrer Datengröße, der Leistungsanforderungen und Ihrer Komplexität. Für die meisten Anwendungsfälle sind Queue oder Manager am einfachsten zu beginnen.

Das obige ist der detaillierte Inhalt vonWie teile ich Daten zwischen mehreren Prozessen in Python aus?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!