Multiprocessing in Python

Il pacchetto di multiprocessori supporta la generazione di processi. Si tratta di una funzione per caricare ed eseguire nuovi sotto-processi. Per far sì che i figli possano terminare o continuare l'esecuzione dei calcoli connessi, il processo attuale deve utilizzare API simili a quelle del modulo thread per attendere.

Introduzione

Quando usiamo Multiprocessing, prima dobbiamo creareproceduraL'oggetto. Poi, chiama unstart()Il metodo.

Esempio di codice

import multiprocessing.Process
　　　def display():
　　　　　　stampa ('Hi !! Io sono Python')
　　　　　　if __name__ == '__main__':
　　　　　　p = Process(target=display)
　　　　　　p.start()
　　　　　　p.join()

In questo esempio, prima importiamo la classe Process, poi usiamo ildisplay()Per avviare l'oggetto Process.

Poi, usiamostart()Il metodo inizia a elaborare e poi usa iljoin()Il metodo è completato.

Possiamo anche passare parametri alla funzione utilizzando la chiave args.

Esempio

import multiprocessing.Process
　　　def display(my_name):
　　　stampa ('Hi !!!' + " " + my_name)
　　　if __name__ == '__main__':
　　　　　　p = Process(target=display, args=('Python',))
　　　　　　p.start()
　　　　　　p.join()

In questo esempio, creiamo un processo che calcola il cubo di un numero e stampa tutti i risultati sulla console.

Esempio di codice

import multiprocessing.Process
　　　def cube(x):
　　　　　　per x in my_numbers:
　　　　　　　　　stampa('%s cubo è %s' % (x, x**3))
　　　　　　if __name__ == '__main__':
　　　　　　　　　my_numbers = [3, 4, 5, 6, 7, 8]
　　　　　　　　　p = Process(target=cube, args=('x',))
　　　　　　　　　p.start()
p.join
stampa ("Fatto")

Risultato di output

Fatto
3 cubo è 27
Il cubo di 4 è 64
Il cubo di 5 è 125
Il cubo di 6 è 216
Il cubo di 7 è 343
Il cubo di 8 è 512

Possiamo anche creare più processi contemporaneamente.

In questo esempio, prima creiamo un processo, ovvero process1, che calcola il cubo di un numero, mentre il secondo processo process2 verifica se il numero è pari o dispari.

Esempio

import multiprocessing.Process
def cube(x):
　　　per x in my_numbers:
　　　stampa('%s cubo è %s' % (x, x**3))
def evenno(x):
　　　per x in my_numbers:
　　　if x % 2 == 0:
　　　stampa('%s è un numero anche' % (x))
　　　if __name__ == '__main__':
　　　　　　my_numbers = [3, 4, 5, 6, 7, 8]
　　　　　　my_process1 = Process(target=cube, args=('x',))
　　　　　　my_process2 = Process(target=evenno, args=('x',))
　　　　　　my_process1.start()
　　　　　　my_process2.start()
　　　　　　my_process1.join()
　　　my_process2.join()
stampa ("Fatto")

Risultato di output

3 cubo è 27
Il cubo di 4 è 64
Il cubo di 5 è 125
Il cubo di 6 è 216
Il cubo di 7 è 343
Il cubo di 8 è 512
4 è un numero pari
6 è un numero pari
8 è un numero pari
Fatto

Comunicazione tra flussi

multiprocessing supporta pipe e queue, che sono due canali di comunicazione tra processi.

Tubo

In multiprocessing, quando dobbiamo comunicare tra processi, in questo caso usiamoPipe.

Esempio

from multiprocessing import Process, Pipe
　　　def myfunction(conn):
　　　　　　conn.send(['hi!! I am Python'])
　　　　　　conn.close()
　　　　　　if __name__ == '__main__':
　　　　　　　　　parent_conn, child_conn = Pipe() p = Process(target=myfunction, args=(child_conn,))
　　　　　　　　　p.start()
　　　　　　print(parent_conn.recv())
p.join()

Risultato di output

['hi !!! I am Python']

La pipe restituisce due oggetti connessione, che rappresentano i due estremi della pipe. Ogni oggetto connessione ha due metodisend(), una possibilità èrecv()Metodo, un altro è metodo.

In questo esempio, prima di tutto, creiamo un processo che stampa il messaggio "hi !! I am Python", quindi condividiamo i dati.

s colonna

Quando passiamo dati tra processi, allora possiamo usare l'oggetto Queue.

Esempio

import multiprocessing
　　　def evenno(numbers, q):
　　　　　　for n in numbers:
　　　　　　if n % 2 == 0:
　　　　　　q.put(n)
　　　　　　if __name__ == "__main__":
　　　　　　　　　q = multiprocessing.Queue()
　　　　　　　　　p = multiprocessing.Process(target=evenno, args=(range(10), q))
　　　　　　　　　p.start()
　　　　　　　　　p.join()
　　　while q:
print(q.get())

Risultato di output

In questo esempio, prima di tutto, creiamo una funzione che verifica se il tempo è un numero pari. Se il numero è pari, lo inseriamo alla fine della coda. Poi creiamo un oggetto coda e un oggetto flusso, quindi avviamo il flusso.

Infine si verifica se la coda è vuota.

Quando stampiamo numeri, prima stampiamo il valore in testa alla coda, poi stampiamo il successivo, e così via.

Chiavi di blocco

In questo caso, se vogliamo eseguire un solo processo alla volta, usiamo Locks. Questo significa che il tempo bloccherà altri processi dall'eseguire codice simile. Dopo che il processo è completato, si rilascia il blocco.

Esempio di utilizzo di Locks

Esempio

from multiprocessing import Process, Lock
def dispmay_name(l, i):
l.acquire()
print('Hi', i)
　　　l.release()
if __name__ == '__main__':
　　　my_lock = Lock() my_name = ['Aadrika', 'Adwaita', 'Sakya', 'Sanj']
for name in my_name:
Process(target=dispmay_name, args=(my_lock, name)).start()

Risultato di output

Hi Aadrika
Hi Adwaita
Hi Sakya
Hi Sanj

Registrazione

Il modulo multi-processing fornisce anche un modulo di registrazione per garantire che i messaggi tra i processi non si mescolino durante l'esecuzione se il pacchetto di registrazione non utilizza la funzione di blocco.

Esempio

import multiprocessing, logging
logger = multiprocessing.log_to_stderr()
logger.setLevel(logging.INFO)
logger.warning('Error has occurred')

In questo esempio, prima si importano i moduli di registrazione e multi-processing, quindi si utilizza il metodo multiprocessing.log_to_stderr(). Poi si chiama get_logger() e si aggiunge a sys.stderr, infine si imposta il livello del registratore e si passa il messaggio.

Corso di base