Prozesse Interkommunikation

Prozesskommunikation bedeutet den Datenaustausch zwischen Prozessen. Es ist notwendig, die Daten zwischen Prozessen auszutauschen, um eine parallele Anwendung zu entwickeln. Das folgende Diagramm zeigt die verschiedenen Kommunikationsmechanismen für die Synchronisation zwischen mehreren Unterprozessen -

Verschiedene Kommunikationsmechanismen

In diesem Abschnitt lernen wir die verschiedenen Kommunikationsmechanismen kennen. Die Mechanismen werden unten beschrieben -

Warteschlangen

Warteschlangen können mit Multiprozessprogrammen verwendet werden. Die Warteschlangenklasse vonmultiprocessing Modul ähnelt dem Queue.QueueKlasse. Daher kann dieselbe API verwendet werden.Multiprocessing.Queue bietet uns einen thread- und prozesssicheren FIFO-Kommunikationsmechanismus (First-In-First-Out) zwischen Prozessen.

Beispiel

Im Folgenden finden Sie ein einfaches Beispiel aus den offiziellen Python-Dokumenten zur Mehrfachverarbeitung, um das Konzept der Multiprozessor-Klasse Queue zu verstehen.

from multiprocessing import Process, Queue
import queue
import random
def f(q):
   q.put([42, None, 'hello'])
def main():
   q = Queue()
   p = Process(target = f, args = (q,))
   p.start()
   print (q.get())
if __name__ == '__main__':
   main()

Ausgabe

[42, None, 'hello']

Rohre

Es ist eine Datenstruktur, die zur Kommunikation zwischen Prozessen in Mehrprozessprogrammen verwendet wird. Die Funktion Pipe () gibt ein Paar von Verbindungsobjekten zurück, die durch eine Pipe verbunden sind, die standardmäßig Duplex (bidirektional) ist. Es funktioniert folgendermaßen:

Es gibt ein Paar Verbindungsobjekte zurück, die die beiden Rohrenden darstellen.
Jedes Objekt hat zwei Methoden - send() und recv(), um zwischen Prozessen zu kommunizieren.

Beispiel

Im Folgenden finden Sie ein einfaches Beispiel aus den offiziellen Python-Dokumenten zur Mehrfachverarbeitung, um das Konzept von zu verstehen Pipe() Funktion der Mehrfachverarbeitung.

from multiprocessing import Process, Pipe

def f(conn):
   conn.send([42, None, 'hello'])
   conn.close()

if __name__ == '__main__':
   parent_conn, child_conn = Pipe()
   p = Process(target = f, args = (child_conn,))
   p.start()
   print (parent_conn.recv())
   p.join()

Ausgabe

[42, None, 'hello']

Manager

Manager ist eine Klasse von Multiprozessor-Modulen, mit denen gemeinsame Informationen zwischen allen Benutzern koordiniert werden können. Ein Managerobjekt steuert einen Serverprozess, der gemeinsam genutzte Objekte verwaltet und es anderen Prozessen ermöglicht, diese zu bearbeiten. Mit anderen Worten, Manager bieten eine Möglichkeit, Daten zu erstellen, die von verschiedenen Prozessen gemeinsam genutzt werden können. Im Folgenden sind die verschiedenen Eigenschaften des Managerobjekts aufgeführt:

Die Haupteigenschaft von Manager ist die Steuerung eines Serverprozesses, der die freigegebenen Objekte verwaltet.
Eine weitere wichtige Eigenschaft besteht darin, alle freigegebenen Objekte zu aktualisieren, wenn ein Prozess sie ändert.

Beispiel

Im Folgenden finden Sie ein Beispiel, in dem das Managerobjekt zum Erstellen eines Listendatensatzes im Serverprozess und zum Hinzufügen eines neuen Datensatzes zu dieser Liste verwendet wird.

import multiprocessing

def print_records(records):
   for record in records:
      print("Name: {0}\nScore: {1}\n".format(record[0], record[1]))

def insert_record(record, records):
   records.append(record)
      print("A New record is added\n")

if __name__ == '__main__':
   with multiprocessing.Manager() as manager:

      records = manager.list([('Computers', 1), ('Histoty', 5), ('Hindi',9)])
      new_record = ('English', 3)

      p1 = multiprocessing.Process(target = insert_record, args = (new_record, records))
      p2 = multiprocessing.Process(target = print_records, args = (records,))
	  p1.start()
      p1.join()
      p2.start()
      p2.join()

Ausgabe

A New record is added

Name: Computers
Score: 1

Name: Histoty
Score: 5

Name: Hindi
Score: 9

Name: English
Score: 3

Konzept der Namespaces im Manager

Manager Class wird mit dem Konzept von Namespaces geliefert, einer schnellen Methode zum Teilen mehrerer Attribute über mehrere Prozesse hinweg. Namespaces verfügen über keine öffentliche Methode, die aufgerufen werden kann, sie verfügen jedoch über beschreibbare Attribute.

Beispiel

Das folgende Python-Skriptbeispiel hilft uns, Namespaces für die gemeinsame Nutzung von Daten zwischen Hauptprozess und untergeordnetem Prozess zu verwenden.

import multiprocessing

def Mng_NaSp(using_ns):

   using_ns.x +=5
   using_ns.y *= 10

if __name__ == '__main__':
   manager = multiprocessing.Manager()
   using_ns = manager.Namespace()
   using_ns.x = 1
   using_ns.y = 1

   print ('before', using_ns)
   p = multiprocessing.Process(target = Mng_NaSp, args = (using_ns,))
   p.start()
   p.join()
   print ('after', using_ns)

Ausgabe

before Namespace(x = 1, y = 1)
after Namespace(x = 6, y = 10)

Ctypes-Array und Wert

Das Multiprocessing-Modul bietet Array- und Value-Objekte zum Speichern der Daten in einer gemeinsam genutzten Speicherzuordnung. Array ist ein ctypes-Array, das aus dem gemeinsam genutzten Speicher und zugewiesen wird Value ist ein ctypes-Objekt, das aus dem gemeinsam genutzten Speicher zugewiesen wird.

Importieren Sie dazu Process, Value, Array aus Multiprocessing.

Beispiel

Das folgende Python-Skript ist ein Beispiel aus Python-Dokumenten, in dem Ctypes Array und Value zum Teilen einiger Daten zwischen Prozessen verwendet werden.

def f(n, a):
   n.value = 3.1415927
   for i in range(len(a)):
   a[i] = -a[i]

if __name__ == '__main__':
   num = Value('d', 0.0)
   arr = Array('i', range(10))

   p = Process(target = f, args = (num, arr))
   p.start()
   p.join()
   print (num.value)
   print (arr[:])

Ausgabe

3.1415927
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

Sequentielle Prozesse kommunizieren (CSP)

CSP wird verwendet, um die Interaktion von Systemen mit anderen Systemen mit gleichzeitigen Modellen zu veranschaulichen. CSP ist ein Framework zum gleichzeitigen Schreiben von Programmen oder Programmen über die Nachrichtenübermittlung und daher zur Beschreibung der Parallelität wirksam.

Python-Bibliothek - PyCSP

Für die Implementierung von Kernprimitiven in CSP verfügt Python über eine Bibliothek namens PyCSP. Es hält die Implementierung sehr kurz und lesbar, so dass es sehr leicht zu verstehen ist. Es folgt das grundlegende Prozessnetzwerk von PyCSP -

Im obigen PyCSP-Prozessnetzwerk gibt es zwei Prozesse - Prozess1 und Prozess 2. Diese Prozesse kommunizieren, indem sie Nachrichten über zwei Kanäle weiterleiten - Kanal 1 und Kanal 2.

PyCSP installieren

Mit Hilfe des folgenden Befehls können wir die Python-Bibliothek PyCSP installieren -

pip install PyCSP

Beispiel

Das folgende Python-Skript ist ein einfaches Beispiel für die parallele Ausführung von zwei Prozessen. Dies geschieht mit Hilfe der PyCSP Python Libabary -

from pycsp.parallel import *
import time
@process
def P1():
   time.sleep(1)
   print('P1 exiting')
@process
def P2():
   time.sleep(1)
   print('P2 exiting')
def main():
   Parallel(P1(), P2())
   print('Terminating')
if __name__ == '__main__':
   main()

Im obigen Skript gibt es nämlich zwei Funktionen P1 und P2 wurden erstellt und dann mit dekoriert @process um sie in Prozesse umzuwandeln.

Ausgabe

P2 exiting
P1 exiting
Terminating