Processi di intercomunicazione

Per intercomunicazione tra processi si intende lo scambio di dati tra processi. È necessario scambiare i dati tra i processi per lo sviluppo dell'applicazione parallela. Il diagramma seguente mostra i vari meccanismi di comunicazione per la sincronizzazione tra più sottoprocessi:

Vari meccanismi di comunicazione

In questa sezione apprenderemo i vari meccanismi di comunicazione. I meccanismi sono descritti di seguito:

Code

Le code possono essere utilizzate con programmi multiprocesso. La classe Queue dimultiprocessing il modulo è simile al Queue.Queueclasse. Quindi, è possibile utilizzare la stessa API.Multiprocessing.Queue ci fornisce un meccanismo di comunicazione FIFO (first-in first-out) sicuro per thread e processi tra processi.

Esempio

Di seguito è riportato un semplice esempio tratto dalla documentazione ufficiale di Python sul multiprocessing per comprendere il concetto di classe Queue di multiprocessing.

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

Produzione

[42, None, 'hello']

Tubi

È una struttura di dati, che viene utilizzata per comunicare tra processi in programmi multi-processo. La funzione Pipe () restituisce una coppia di oggetti di connessione collegati da una pipe che per impostazione predefinita è duplex (bidirezionale). Funziona nel modo seguente:

  • Restituisce una coppia di oggetti di connessione che rappresentano le due estremità del tubo.

  • Ogni oggetto ha due metodi: send() e recv(), per comunicare tra i processi.

Esempio

Di seguito è riportato un semplice esempio tratto dalla documentazione ufficiale di Python sul multiprocessing per comprendere il concetto di Pipe() funzione di multiprocessing.

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

Produzione

[42, None, 'hello']

Manager

Manager è una classe di modulo multiprocessing che fornisce un modo per coordinare le informazioni condivise tra tutti i suoi utenti. Un oggetto gestore controlla un processo del server, che gestisce gli oggetti condivisi e consente ad altri processi di manipolarli. In altre parole, i manager forniscono un modo per creare dati che possono essere condivisi tra diversi processi. Di seguito sono riportate le diverse proprietà dell'oggetto gestore:

  • La proprietà principale di manager è controllare un processo server, che gestisce gli oggetti condivisi.

  • Un'altra proprietà importante è aggiornare tutti gli oggetti condivisi quando un processo lo modifica.

Esempio

Di seguito è riportato un esempio che utilizza l'oggetto manager per creare un record di elenco nel processo del server e quindi aggiungere un nuovo record in tale elenco.

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

Produzione

A New record is added

Name: Computers
Score: 1

Name: Histoty
Score: 5

Name: Hindi
Score: 9

Name: English
Score: 3

Concetto di spazi dei nomi in Manager

Manager Class viene fornito con il concetto di spazi dei nomi, che è un metodo rapido per condividere diversi attributi tra più processi. Gli spazi dei nomi non presentano alcun metodo pubblico, che può essere chiamato, ma hanno attributi scrivibili.

Esempio

Il seguente esempio di script Python ci aiuta a utilizzare gli spazi dei nomi per condividere i dati tra il processo principale e il processo figlio -

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)

Produzione

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

Ctypes-Array e Value

Il modulo Multiprocessing fornisce oggetti Array e Value per memorizzare i dati in una mappa di memoria condivisa. Array è un array ctypes allocato dalla memoria condivisa e Value è un oggetto ctypes allocato dalla memoria condivisa.

Per stare con, importa Process, Value, Array dal multiprocessing.

Esempio

Il seguente script Python è un esempio tratto dalla documentazione di Python per utilizzare Ctypes Array e Value per la condivisione di alcuni dati tra i processi.

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

Produzione

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

Comunicazione dei processi sequenziali (CSP)

CSP viene utilizzato per illustrare l'interazione dei sistemi con altri sistemi dotati di modelli concorrenti. CSP è un framework per la scrittura simultanea o programma tramite il passaggio di messaggi e quindi è efficace per descrivere la concorrenza.

Libreria Python - PyCSP

Per l'implementazione delle primitive di base trovate in CSP, Python ha una libreria chiamata PyCSP. Mantiene l'implementazione molto breve e leggibile in modo che possa essere compresa molto facilmente. Di seguito è riportata la rete di processo di base di PyCSP:

Nella rete di processi PyCSP sopra, ci sono due processi: Processo1 e Processo 2. Questi processi comunicano passando messaggi attraverso due canali: canale 1 e canale 2.

Installazione di PyCSP

Con l'aiuto del seguente comando, possiamo installare la libreria Python PyCSP -

pip install PyCSP

Esempio

Il seguente script Python è un semplice esempio per eseguire due processi in parallelo tra loro. È fatto con l'aiuto della libreria PyCSP Python -

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

Nello script sopra, due funzioni vale a dire P1 e P2 sono stati creati e poi decorati con @process per convertirli in processi.

Produzione

P2 exiting
P1 exiting
Terminating