Processus Intercommunication

L'intercommunication de processus signifie l'échange de données entre les processus. Il est nécessaire d'échanger les données entre les processus pour le développement d'applications parallèles. Le diagramme suivant montre les différents mécanismes de communication pour la synchronisation entre plusieurs sous-processus -

Divers mécanismes de communication

Dans cette section, nous découvrirons les différents mécanismes de communication. Les mécanismes sont décrits ci-dessous -

Files d'attente

Les files d'attente peuvent être utilisées avec des programmes multi-processus. La classe Queue demultiprocessing module est similaire au Queue.Queueclasse. Par conséquent, la même API peut être utilisée.Multiprocessing.Queue nous fournit un mécanisme de communication FIFO (premier entré premier sorti) sûr pour les threads et les processus.

Exemple

Voici un exemple simple tiré de la documentation officielle de python sur le multitraitement pour comprendre le concept de classe de file d'attente du multitraitement.

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()

Production

[42, None, 'hello']

Tuyaux

C'est une structure de données, qui est utilisée pour communiquer entre les processus dans les programmes multi-processus. La fonction Pipe () renvoie une paire d'objets de connexion connectés par un tuyau qui par défaut est duplex (bidirectionnel). Cela fonctionne de la manière suivante -

  • Il renvoie une paire d'objets de connexion qui représentent les deux extrémités du tuyau.

  • Chaque objet a deux méthodes - send() et recv(), pour communiquer entre les processus.

Exemple

Voici un exemple simple tiré de la documentation officielle de python sur le multitraitement pour comprendre le concept de Pipe() fonction du multitraitement.

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()

Production

[42, None, 'hello']

Directeur

Manager est une classe de module multitraitement qui fournit un moyen de coordonner les informations partagées entre tous ses utilisateurs. Un objet gestionnaire contrôle un processus serveur, qui gère les objets partagés et permet à d'autres processus de les manipuler. En d'autres termes, les gestionnaires fournissent un moyen de créer des données qui peuvent être partagées entre différents processus. Voici les différentes propriétés de l'objet gestionnaire -

  • La propriété principale du manager est de contrôler un processus serveur, qui gère les objets partagés.

  • Une autre propriété importante est de mettre à jour tous les objets partagés lorsqu'un processus le modifie.

Exemple

Voici un exemple qui utilise l'objet gestionnaire pour créer un enregistrement de liste dans le processus serveur, puis ajouter un nouvel enregistrement dans cette liste.

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()

Production

A New record is added

Name: Computers
Score: 1

Name: Histoty
Score: 5

Name: Hindi
Score: 9

Name: English
Score: 3

Concept d'espaces de noms dans Manager

Manager Class est livré avec le concept d'espaces de noms, qui est une méthode rapide pour partager plusieurs attributs entre plusieurs processus. Les espaces de noms ne comportent aucune méthode publique, qui peut être appelée, mais ils ont des attributs inscriptibles.

Exemple

L'exemple de script Python suivant nous aide à utiliser les espaces de noms pour partager des données entre le processus principal et le processus enfant -

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)

Production

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

Ctypes-Array et valeur

Le module de multitraitement fournit des objets Array et Value pour stocker les données dans une carte de mémoire partagée. Array est un tableau ctypes alloué à partir de la mémoire partagée et Value est un objet ctypes alloué à partir de la mémoire partagée.

Pour être avec, importez Process, Value, Array à partir du multiprocessing.

Exemple

Le script Python suivant est un exemple tiré de la documentation python pour utiliser Ctypes Array et Value pour partager certaines données entre les processus.

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[:])

Production

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

Communication des processus séquentiels (CSP)

CSP est utilisé pour illustrer l'interaction des systèmes avec d'autres systèmes comportant des modèles concurrents. CSP est un cadre pour l'écriture simultanée ou d'un programme via le passage de messages et est donc efficace pour décrire la concurrence.

Bibliothèque Python - PyCSP

Pour implémenter les primitives de base trouvées dans CSP, Python dispose d'une bibliothèque appelée PyCSP. Il maintient la mise en œuvre très courte et lisible afin qu'elle puisse être comprise très facilement. Voici le réseau de processus de base de PyCSP -

Dans le réseau de processus PyCSP ci-dessus, il existe deux processus - Process1 et Process 2. Ces processus communiquent en passant des messages via deux canaux - canal 1 et canal 2.

Installation de PyCSP

Avec l'aide de la commande suivante, nous pouvons installer la bibliothèque Python PyCSP -

pip install PyCSP

Exemple

Le script Python suivant est un exemple simple pour exécuter deux processus en parallèle l'un de l'autre. Cela se fait à l'aide de la bibliothèque Python PyCSP -

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()

Dans le script ci-dessus, deux fonctions à savoir P1 et P2 ont été créés puis décorés avec @process pour les convertir en processus.

Production

P2 exiting
P1 exiting
Terminating