Python vs. threading multiprocessing in Linux

Question

Sulla base di questo question ho ipotizzato che la creazione di nuovo processo dovrebbe essere quasi veloce come la creazione dinuovo thread in Linux. Tuttavia, un piccolo test ha mostrato risultati molto diversi. Ecco il mio codice:

from multiprocessing import Process, Pool 
from threading import Thread 

times = 1000 

def inc(a): 
    b = 1 
    return a + b 

def processes(): 
    for i in xrange(times): 
     p = Process(target=inc, args=(i,)) 
     p.start() 
     p.join() 

def threads(): 
    for i in xrange(times): 
     t = Thread(target=inc, args=(i,)) 
     t.start() 
     t.join() 

Test:

>>> timeit processes() 
1 loops, best of 3: 3.8 s per loop 

>>> timeit threads() 
10 loops, best of 3: 98.6 ms per loop 

Così, i processi sono quasi 40 volte più lento per creare! Perché succede? E 'specifico per Python o queste librerie? O ho semplicemente interpretato male la risposta sopra?

---

UPD 1. Per renderlo più chiaro. Comprendo che questa parte di codice non introduce alcuna concorrenza. L'obiettivo qui è di testare il tempo necessario per creare un processo e un thread. Per utilizzare vera e propria concorrenza con Python si può usare qualcosa di simile a questo:

def pools(): 
    pool = Pool(10) 
    pool.map(inc, xrange(times)) 

che corre in realtà molto più veloce rispetto alla versione filettata.

---

UPD 2. Ho aggiunto la versione con os.fork():

for i in xrange(times): 
    child_pid = os.fork() 
    if child_pid: 
     os.waitpid(child_pid, 0) 
    else: 
     exit(-1) 

I risultati sono:

$ time python test_fork.py 

real 0m3.919s 
user 0m0.040s 
sys  0m0.208s 

$ time python test_multiprocessing.py 

real 0m1.088s 
user 0m0.128s 
sys  0m0.292s 

$ time python test_threadings.py 

real 0m0.134s 
user 0m0.112s 
sys  0m0.048s 

Answer 1

La domanda a cui si è collegati sta confrontando il costo della semplice chiamata allo fork(2) rispetto allo pthread_create(3), mentre il codice fa un bel po 'di più, ad es. utilizzando join() per attendere che i processi/thread terminino.

Se, come dici tu ...

L'obiettivo qui è quello di testare il tempo necessario per creare un processo e un filo.

... quindi non dovresti aspettare che vengano completati. Si deve usare i programmi di test più come questi ...

fork.py

import os 
import time 

def main(): 
    for i in range(100): 
     pid = os.fork() 
     if pid: 
      #print 'created new process %d' % pid 
      continue 
     else: 
      time.sleep(1) 
      return 

if __name__ == '__main__': 
    main() 

thread.py

import thread 
import time 

def dummy(): 
    time.sleep(1) 

def main(): 
    for i in range(100): 
     tid = thread.start_new_thread(dummy,()) 
     #print 'created new thread %d' % tid 

if __name__ == '__main__': 
    main() 

... che danno i seguenti risultati ..

$ time python fork.py 
real 0m0.035s 
user 0m0.008s 
sys  0m0.024s 

$ time python thread.py 
real 0m0.032s 
user 0m0.012s 
sys  0m0.024s 

... s o non c'è molta differenza nel tempo di creazione di thread e processi.

Answer 2

Sì, è vero. Iniziare un nuovo processo (chiamato processo pesante) è costoso.

Come una panoramica ...

Il sistema operativo deve (nel caso di Linux) Forcella il primo processo, impostare la contabilità per il nuovo processo, impostare il nuovo stack, fare il cambio di contesto, copia qualsiasi memoria che viene cambiata e distruggere tutto quando il nuovo processo ritorna.

Il thread assegna appena un nuovo stack e struttura del thread, esegue il contesto switch e restituisce quando il lavoro è terminato.

... è per questo che utilizziamo i thread.

Answer 3

Nella mia esperienza c'è una differenza significativa tra la creazione di un thread (con pthread_create) e la forking di un processo.

Per esempio ho creato un test C simile al vostro test di pitone con il codice di filo in questo modo:

pthread_t thread; 
pthread_create(&thread, NULL, &test, NULL); 
void *res; 
pthread_join(thread, &res); 

e di processo codice forking in questo modo:

pid_t pid = fork(); 
if (!pid) { 
    test(NULL); 
    exit(0); 
}   
int res; 
waitpid(pid, &res, 0); 

Sul mio sistema il codice forking preso circa 8 volte più lungo da eseguire.

Tuttavia, vale la pena notare che l'implementazione di Python è ancora più lenta - per me è stata circa 16 volte più lenta.Sospetto che sia perché oltre al normale sovraccarico di creazione di un nuovo processo, c'è anche più overhead di Python associato al nuovo processo.