Multiprocessing in Python | Una guida per principianti al multiprocessing in Python

import multiprocessing
import time

def sleepy_man(secondo):
    Stampa("Iniziare a dormire per {} seconds'.format(secondo))
    tempo.dormire(secondo)
    Stampa('Fatto dormire per {} seconds'.format(secondo))

tic = tempo.tempo()

pool = multiprocessing. Pozza(5)
pool.map(sleepy_man, gamma(1,11))
pool.chiudi()

toc = time.time()

Stampa(«Fatto in {:.4F} seconds'.format(toc-tic))

Pool Multiprocessing (5) definisce il numero di lavoratori. Qui definiamo il numero come 5. pool.map () è il metodo che attiva l'esecuzione della funzione. Chiamare pool.map (hombre_soñoliento, classifica (1,11)). Qui, hombre_soñoliento è la funzione da chiamare con i parametri per le esecuzioni di funzioni definite da classifica (1,11) (Di solito viene passato un elenco). L'output è il seguente:

Iniziare a dormire per 1 seconds
Starting to sleep for 2 seconds
Starting to sleep for 3 seconds
Starting to sleep for 4 seconds
Starting to sleep for 5 seconds
Done sleeping for 1 seconds
Starting to sleep for 6 seconds
Done sleeping for 2 seconds
Starting to sleep for 7 seconds
Done sleeping for 3 seconds
Starting to sleep for 8 seconds
Done sleeping for 4 seconds
Starting to sleep for 9 seconds
Done sleeping for 5 seconds
Starting to sleep for 10 seconds
Done sleeping for 6 seconds
Done sleeping for 7 seconds
Done sleeping for 8 seconds
Done sleeping for 9 seconds
Done sleeping for 10 seconds
Done in 15.0210 Secondi

Piscina è un modo migliore per implementare il multiprocessing perché distribuisce le attività ai processori disponibili utilizzando il programma First Enter, primo fuori. È quasi simile all'architettura di riduzione della mappa, in sostanza, assegna l'input a diversi processori e raccoglie l'output da tutti i processori come un elenco. I processi in esecuzione sono archiviati in memoria e altri processi non in esecuzione sono archiviati in memoria.

Nel frattempo Processi classe, tutti i processi vengono eseguiti in memoria e la loro esecuzione è pianificata utilizzando la politica FIFO.

Confronto delle prestazioni temporali per calcolare numeri perfetti-

import time

def is_perfect(n):
    sum_factors = 0
    per io nel raggio d'azione(1, n):
        Se (n % i == 0):
            sum_factors = sum_factors + i
    if (sum_factors == n):
        Stampa('{} è un numero perfetto'.format(n))

tic = tempo.tempo()
per n nell'intervallo(1,100000):
    is_perfect(n)
toc = time.time()

Stampa(«Fatto in {:.4F} seconds'.format(toc-tic))

6 è un numero perfetto
28 è un numero perfetto
496 è un numero perfetto
8128 is a Perfect number
Done in 258.8744 Secondi

import time
import multiprocessing

def is_perfect(n):
    sum_factors = 0
    per io nel raggio d'azione(1, n):
        Se(n % i == 0):
            sum_factors = sum_factors + i
    if (sum_factors == n):
        Stampa('{} è un numero perfetto'.format(n))

tic = tempo.tempo()

processi = []
per io nel raggio d'azione(1,100000):
    p = multiprocessing. Processo(target=is_perfect, args=(io,))
    processes.append(P)
    p.start()

per il processo nei processi:
    process.join()

toc = time.time()
Stampa(«Fatto in {:.4F} seconds'.format(toc-tic))

6 è un numero perfetto
28 è un numero perfetto
496 è un numero perfetto
8128 is a Perfect number
Done in 143.5928 Secondi

import time
import multiprocessing

def is_perfect(n):
    sum_factors = 0
    per io nel raggio d'azione(1, n):
        Se(n % i == 0):
            sum_factors = sum_factors + i
    if (sum_factors == n):
        Stampa('{} è un numero perfetto'.format(n))

tic = tempo.tempo()
pool = multiprocessing. Pozza()
pool.map(is_perfect, gamma(1,100000))
pool.chiudi()
toc = time.time()

Stampa(«Fatto in {:.4F} seconds'.format(toc-tic))

6 è un numero perfetto
28 è un numero perfetto
496 è un numero perfetto
8128 is a Perfect number
Done in 74.2217 Secondi