Python多处理是重复的

我将子进程创建为

worker

对象，这些对象通过

input

和

output

队列获取和返回数据。 但是，当代码运行时，似乎每个子进程都获得了

输入

队列的完整副本，并且主线程没有通过

输出

队列获取任何内容，这导致了死锁。为什么呢

import threading, queue, multiprocessing
class worker(multiprocessing.Process):
     def __init__(self,inp,out):
         super().__init__()
         self.input=inp
         self.output=out
         #real program has external subprocess initialization here
     def run(self):
         name=self.name
         while True:
             inp=self.input.get()
             if (inp is 'stop'):
                 break
             print('Process {} got task word: {}'.format(name,inp))
             print('queue size is: {}'.format(self.input.qsize()))
             self.output.put(inp.count('a'))
             print('Process {} input processed'.format(name))
         print('exiting {}'.format(name))

if __name__ == "__main__":
    inp=queue.Queue()
    out=queue.Queue(maxsize=4)
    strings = ['asd', 'assa','aaa','as','aa','aaaq']
    for x in strings:
        inp.put(x)
    print(inp.qsize())
    workers=[worker(inp,out) for x in range(2)]
    for w in workers:
        w.start()
    res=[]
    for x in strings:
        res.append(out.get())
        print("intermediate result is {}".format(res))
    for _ in workers:
        inp.put('stop')
    for w in workers:
        w.join()

    print(res)

在实际问题中，每个工作者都会初始化自己与另一个外部程序的接口。我希望避免对每个项重复初始化，因此我不能简单地将worker转换为函数并将其与

map

一起使用

---

如果将

多处理.Process

替换为具有相同api的

线程.Thread

，则程序工作正常，但在单核上，这对于任务是不可接受的。

不同的进程不共享进程内存，因此无法在不同的进程之间共享队列。每个进程都有自己的副本

您必须使用IPC机制来同步多个进程

但是，线程共享进程内存，因此它只适用于线程，而不适用于进程

多进程的解决方案 使用多处理队列

import threading, multiprocessing
class worker(multiprocessing.Process):
     def __init__(self,inp,out):
         super().__init__()
         self.input=inp
         self.output=out
         #real program has external subprocess initialization here
     def run(self):
         name=self.name
         while True:
             inp=self.input.get()
             if (inp == 'stop'):
                 break
             print('Process {} got task word: {}'.format(name,inp))
             #print('queue size is: {}'.format(self.input.qsize()))
             self.output.put((inp, inp.count('a')))
             print('Process {} input processed'.format(name))
         print('exiting {}'.format(name))

if __name__ == "__main__":
    inp=multiprocessing.Queue()
    out=multiprocessing.Queue()
    strings = ['asd', 'assa','aaa','as','aa','aaaq']
    for x in strings:
        inp.put(x)

    workers=[worker(inp,out) for x in range(2)]
    for w in workers:
        w.start()

    for _ in workers:
        inp.put('stop')
    #print (inp.qsize())


    inp.close()
    inp.join_thread()

    for w in workers:
        w.join()

    print (out.empty())
    while not out.empty():
        print (out.get())

---

在开始工作后，main中的代码将继续运行，直到调用w.join（）。因此，收集输出太早。根据您的处理器/系统，当您获得输出时，工作可能已经开始，也可能尚未开始。还有其他问题，但我没有办法检查。是的，我没有意识到

queue.queue

没有为流程提供正确的队列。然而，不需要改变从队列读取和加入工人的顺序。使用队列背后的整个想法是让工人的寿命超过输入和输出（它们可能很大，并且不需要同时存在）@Dimitry是的，没有必要更改顺序，我只是尝试了一些东西，没有更改回来。很高兴这有帮助：）