Elaborazione multipla Python> = 125 lista non finisce mai

Question

Sto cercando di implementare questo multiprocessing tutorial per i miei scopi. All'inizio ho pensato che non fosse scalabile, ma quando ho fatto un esempio riproducibile ho scoperto che se l'elenco degli oggetti supera 124, sembra non restituire mai una risposta. A x = 124 funziona in .4 secondi, ma quando lo imposto su x = 125 non finisce mai. Sto eseguendo Python 2.7 su Windows 7.

from multiprocessing import Lock, Process, Queue, current_process 
import time 

class Testclass(object): 
    def __init__(self, x): 
     self.x = x 

def toyfunction(testclass): 
    testclass.product = testclass.x * testclass.x 
    return testclass 


def worker(work_queue, done_queue): 
    try: 
     for testclass in iter(work_queue.get, 'STOP'): 
      print(testclass.counter) 
      newtestclass = toyfunction(testclass) 
      done_queue.put(newtestclass) 

    except: 
     print('error') 

    return True 

def main(x): 

    counter = 1 

    database = [] 
    while counter <= x: 
     database.append(Testclass(10)) 
     counter += 1 
     print(counter) 



    workers = 8 
    work_queue = Queue() 
    done_queue = Queue() 
    processes = [] 

    start = time.clock() 
    counter = 1 

    for testclass in database: 
     testclass.counter = counter 
     work_queue.put(testclass) 
     counter += 1 
     print(counter) 


    print('items loaded') 
    for w in range(workers): 
     p = Process(target=worker, args=(work_queue, done_queue)) 
     p.start() 
     processes.append(p) 
     work_queue.put('STOP') 

    for p in processes: 
     p.join() 

    done_queue.put('STOP') 

    newdatabase = [] 
    for testclass in iter(done_queue.get, 'STOP'): 
     newdatabase.append(testclass) 

    print(time.clock()-start) 
    print("Done") 
    return(newdatabase) 

if __name__ == '__main__': 
    database = main(124) 
    database2 = main(125) 

Answer 1

OK! Da the docs:

Attenzione Come accennato in precedenza, se un processo figlio ha messo gli elementi su una coda (e non ha usato JoinableQueue.cancel_join_thread), allora questo processo non terminerà fino a quando tutti gli elementi tamponati sono stati lavati alla pipa. Ciò significa che se provi ad unirti a quel processo potresti ottenere un deadlock a meno che non sei sicuro di che tutti gli elementi che sono stati messi in coda siano stati consumati. Allo stesso modo, se il processo figlio è non-demonico, il processo genitore potrebbe bloccarsi all'uscita quando tenta di di unirsi a tutti i suoi figli non demoniaci. Si noti che una coda creata utilizzando un manager non ha questo problema. Vedi le linee guida sulla programmazione.

Come ho sottolineato in un commento precedente, il codice tenta di .join() processi prima il done_queue coda viene scaricata - e che dopo aver cambiato il codice in modo funky per essere sicuri done_queue fu prosciugato prima .join() 'ing, il codice funzionava bene per un milione di articoli.

Quindi questo è un caso di errore del pilota, sebbene piuttosto oscuro. Per quanto riguarda il motivo per cui il comportamento dipende dal numero passato a main(x), è imprevedibile: dipende da come il buffering viene eseguito internamente. Tale divertimento ;-)