Sincronizzazione e poolizzazione dei processi in Python

Sincronizzazione tra flussi di lavoro

Il multiprocessamento è un pacchetto che supporta la generazione di programmi utilizzando l'API. Questo pacchetto è utilizzato per la concorrenza locale e remota. Utilizzando questo modulo, gli sviluppatori possono utilizzare più processori sul computer specificato. Può essere eseguito su sistemi operativi Windows e UNIX.

Questo pacchetto contiene tutti gli atomi di sincronizzazione equivalenti.

Esempio di codice

from multiprocessing import Process, Lock
　　　def my_function(x, y):
　　　　　　x.acquire()
　　　　　　print('hello world', y)
　　　　　　x.release()
　　　　　　if __name__ == '__main__':
　　　　　　lock = Lock() for num in range(10):
Process(target=my_function, args=(lock, num)).start()

In questo contesto, un esempio può essere bloccato per assicurarsi che solo un processo possa visualizzare l'output standard in una volta.

Raccolta

Per il pool, utilizziamo la classe Pool. Quando qualcuno può creare un pool di processo, porterà tutte le attività presentate a lui.

class　multiprocessing.Pool([processes[,　initializer[,　initargs[,　maxtasksperchild]]]])

L'oggetto pool controlla il pool di lavoro per selezionare i compiti che possono essere presentati, supporta risultati asincroni con timeout, callback e implementazione di mappatura parallela.

Se il processo è vuoto, utilizzare cpu_count(); se inizializzato non None, chiamare questa funzione con initializer(* initargs).

apply(func[,　args[,　kwds]])

Questo è simile aapply()Ha lo stesso comportamento della funzione built-in. Blocca fino a che il risultato non è pronto, se si desidera eseguire in parallelo, è meglio utilizzare il metodo apply_async().

apply_async(func[,　args[,　kwds[,　callback]]])

Restituisce un oggetto di risultato.

map(func, iterabile[，chunksize])

map() è una funzione built-in che supporta solo un parametro iterabile. Blocca fino a che il risultato non è pronto.

In questo metodo, l'iterabile viene diviso in molti pezzi e questi pezzi vengono presentati come task singoli al pool di processo.

map_async(func, iterable [，chunksize [，callback]])

Restituisce un oggetto di risultato.

imap(func, iterable [，chunksize])

Simile a itertools.imap().

La dimensione dei parametri è la stessamap().

imap_unordered(func, iterable [，chunksize])

Questo è simile aimap()Riorganizzare l'ordine dell'iteratore allo stesso modo.

Chiudere()

Dopo che il personale ha completato tutte le attività, il personale esce dal flusso.

Terminare()

Se dobbiamo fermare immediatamente il processo di lavoro senza completare il lavoro, utilizzare questo metodo.

join()

Quando si utilizzajoin()Prima di utilizzareclose()eterminate()Funzione.

Classe multiprocessing.pool.AsyncResult

Restituito da Pool.apply_async() e Pool.map_async().

get([timeout])

Questa funzione restituisce il risultato al momento dell'arrivo.

Attesa ([timeout])

Utilizzando questa funzione di attesa, aspettiamo che il risultato sia disponibile o fino a che siano trascorsi secondi di timeout.

Preparazione()

Questa funzione restituisce se la chiamata è completata.

Successo()

Dopo la chiamata non ci sono errori, questa funzione restituirà.

Esempio di codice

# -*- coding: utf-8 -*-

Creato il lunedì 30 set 2018 12:17:58
@autore: oldtoolbag.com

from multiprocessing import Pool
import time
def myfunction(m):
return m*m
if __name__ == '__main__':
my_pool = Pool(processes=4) # avvia 4 processi di lavoro
result = my_pool.apply_async(myfunction, (10,)) # valuta "f(10)" asincronamente in un singolo processo
print (result.get(timeout=1))
print (my_pool.map(myfunction, range(10))) # stampa "[0, 1, 4,..., 81]"
my_it = my_pool.imap(myfunction, range(10))
print (my_it.next()) # stampa "0"
print (my_it.next()) # stampa "1"
print (my_it.next(timeout=1)) # stampa "4" a meno che il tuo computer non sia *molto* lento
result = my_pool.apply_async(time.sleep, (10,))
print (result.get(timeout=1)) # solleva l'errore di TimeoutError di multiprocessing