Python 多处理与多线程相结合

我不确定我想做的是否是有效的做法，但事情是这样的： 我需要我的程序高度并行化，所以我想我可以创建 2-3 个进程，每个进程可以有 2-3 个线程。

1）这可能吗？ 2）这有什么意义吗？ 3）这是我的代码，但当我尝试加入进程时它会挂起。

PQ = multiprocessing.Queue()

[...]

def node(self, files, PQ):

        l1, l2 = self.splitList(files)
        p1 = multiprocessing.Process(target=self.filePro, args=(l1,PQ,))
        p2 = multiprocessing.Process(target=self.filePro, args=(l2,PQ,))
        p1.daemon = True
        p2.daemon = True
        p1.start()
        p2.start()

        p1.join() # HANGS HERE
        p2.join()
        while 1:
            if PQ.empty():
                break
            else:
                print(PQ.get())
        PQ.join()

    def filePro(self,lst,PQ):
        TQ = queue.Queue()
        l1, l2 = self.splitList(lst)
        t1 = threading.Thread(target=self.fileThr, args=('a',l1,TQ,))
        t2 = threading.Thread(target=self.fileThr, args=('b',l2,TQ,))
        t1.daemon = True
        t2.daemon = True
        t1.start()
        t2.start()

        t1.join()
        t2.join()
        while 1:
            if TQ.empty():
                break
            else:
                PQ.put(TQ.get())
                TQ.task_done()
        TQ.join()

def fileThr(self,id,lst,TQ):
        while lst:
            tmp_path = lst.pop()
            if (not tmp_path[1]):
                continue
            for item in tmp_path[1]:
                TQ.put(1)
        TQ.join()

1）这可能吗？

Yes.

2）这有什么意义吗？

是的。但通常不是您要寻找的点。

首先，几乎每个现代操作系统都使用“平面”调度程序；分散在 3 个程序中的 8 个线程或分散在 8 个程序中的 8 个线程之间没有区别。*

_{* Some programs can get a significant benefit by carefully using intraprocess-only locks or other synchronization primitives in some places where you know you're only sharing with threads from the same program—and, of course, by avoiding shared memory in those places—but you're not going to get that benefit by spreading your jobs across threads and your threads across processes evenly.}

其次，即使您使用旧的 SunOS，在默认的 CPython 解释器中，全局解释器锁 (GIL) 也会确保一次只有一个线程可以运行 Python 代码。如果您花时间从显式释放 GIL 的 C 扩展库（如某些 NumPy 函数）运行代码，线程可以提供帮助，但否则，它们最终都会被序列化。

线程和进程一起使用的主要情况是同时处理 CPU 密集型和 I/O 密集型工作。在这种情况下，通常一个人正在喂另一个人。如果 I/O 为 CPU 提供数据，请在主进程中使用单个线程池来处理 I/O，然后使用工作进程池来对结果执行 CPU 工作。如果是相反的方式，请使用工作进程池来执行 CPU 工作，然后让每个工作进程使用线程池来执行 I/O。

3）这是我的代码，但当我尝试加入进程时它会挂起。

当你不给出一个信息时，调试代码是非常困难的最小的、完整的、可验证的示例 https://stackoverflow.com/help/mcve.

然而，我可以看到一个明显的问题。

你正在尝试使用TQ作为生产者-消费者队列，t1 and t2作为生产者和filePro父母作为消费者。您的消费者不打电话TQ.task_done()直到之后t1.join() and t2.join()返回，直到这些线程完成后才会发生。但那些制作人不会完成，因为他们在等你打电话TQ.task_done()。所以，你陷入了僵局。

而且，因为每个子进程的主线程都死锁，它们永远不会完成，所以p1.join()将永远阻塞。

如果您确实希望主线程在执行任何工作之前等待其他线程完成，则不需要生产者-消费者习惯用法；让孩子们做完他们的事然后退出而不打电话TQ.join()，并且不用担心TQ.task_done()在父级中。 （请注意，您已经正确执行了此操作PQ.)

另一方面，如果您希望它们并行工作，请不要尝试join子线程直到你完成循环。