Estou trabalhando em um projeto bastante grande em Python que requer que uma das tarefas em segundo plano com uso intenso de computação seja transferida para outro núcleo, para que o serviço principal não fique lento. Eu me deparei com algum comportamento aparentemente estranho ao usarmultiprocessing.Queue para comunicar resultados do processo de trabalho. Usando a mesma fila para umthreading.Thread e ummultiprocessing.Process para fins de comparação, o encadeamento funciona bem, mas o processo falha ao unir depois de colocar um item grande na fila. Observar:

<code>import threading
import multiprocessing

class WorkerThread(threading.Thread):
    def __init__(self, queue, size):
        threading.Thread.__init__(self)
        self.queue = queue
        self.size = size

    def run(self):
        self.queue.put(range(size))


class WorkerProcess(multiprocessing.Process):
    def __init__(self, queue, size):
        multiprocessing.Process.__init__(self)
        self.queue = queue
        self.size = size

    def run(self):
        self.queue.put(range(size))


if __name__ == "__main__":
    size = 100000
    queue = multiprocessing.Queue()

    worker_t = WorkerThread(queue, size)
    worker_p = WorkerProcess(queue, size)

    worker_t.start()
    worker_t.join()
    print 'thread results length:', len(queue.get())

    worker_p.start()
    worker_p.join()
    print 'process results length:', len(queue.get())
</code>

Eu vi que isso funciona bem parasize = 10000, mas trava emworker_p.join() parasize = 100000. Existe algum limite de tamanho inerente ao quemultiprocessing.Process instâncias pode colocar em ummultiprocessing.Queue? Ou estou cometendo algum erro fundamental e óbvio aqui?

Para referência, estou usando o Python 2.6.5 no Ubuntu 10.04.