问题标签 [python-multiprocessing]

我需要能够在其中创建带有 pySerial 对象的共享对象。从位置列表中找到设备后，该对象将仅由子进程创建一次。其他进程将在以后使用它。

Python 多处理管理器无法知道嵌入到其他对象的对象的更改。因此，如果我创建经理：

我可以在进程之间共享对象。

在哪里

现在我将在子进程中运行它：

并打印结果：

输出：

我希望能够使用简单的代码，例如：

ns.obj.ser.write(), ns.obj.somemethod(arg) 其中

但我不能参考ns.obj.ser，因为如果它将从新进程运行，它将被视为未定义。如果我们在 conntrollers.py 中的其他方法中引用 self.ser 并尝试在新进程中运行它们，我们也会遇到同样的情况。

编辑：我找到了将命名空间导入模块的方法：

或者在创建对象时将 ns 发送到init 。但问题依然存在。ns.obj 是 NoneType 对象，因为该对象仍在创建过程中。所以我不能输入 ns.obj.ser= self.ser 如果我尝试将 ns 发送到 SerialReader()

并尝试在 SerialReader_init _ 中打印它我得到：

我也无法添加 ser..

我正在开发一个渲染农场，我需要我的客户能够启动渲染器的多个实例，而不会阻塞，以便客户端可以接收新命令。我已经正常工作了，但是我在终止创建的进程时遇到了麻烦。

在全局级别，我定义了我的池（以便我可以从任何函数访问它）：

然后我用 apply_async 调用我的渲染器：

该函数完成，在后台启动进程，并等待新命令。我做了一个简单的命令，它将杀死客户端并停止渲染：

它似乎没有给出错误（它会打印错误），python 终止但后台进程仍在运行。谁能推荐一种更好的方法来控制这些启动的程序？

我似乎对Manager.dict()传递给函数列表（在子进程中）的 a 有问题，因为当我在函数中修改它时，新值在外部不可用。我创建这样的函数列表：

然后这样称呼它：

现在假设我们正在谈论flush_macs()，无论我在 maclist 函数中做什么，似乎都不会影响我函数之外的 maclist - 为什么会这样？我如何修改它以使我的更改在外部可用？

First question is what is the difference between Value and Manager().Value?

Second, is it possible to share integer variable without using Value? Below is my sample code. What I want is getting a dict with a value of integer, not Value. What I did is just change it all after the process. Is there any easier way?

多处理是python中一个强大的工具，我想更深入地了解它。我想知道何时使用常规 锁和队列以及何时使用多处理管理器在所有进程之间共享这些。

我提出了以下测试场景，其中有四种不同的多处理条件：

1. 使用池和NO管理器

2. 使用池和管理器

3. 使用单独的流程和NO Manager

4. 使用单独的流程和管理器

工作

所有条件都执行一个作业功能the_job。the_job由一些由锁固定的印刷组成。此外，函数的输入只是简单地放入一个队列中（看是否可以从队列中恢复）。此输入只是在名为（显示在底部）的主脚本中创建idx的索引。range(10)start_scenario

条件的成功被定义为从队列中完全调用输入，请参见read_queue底部的函数。

条件

条件 1 和 2 是不言自明的。条件 1 涉及创建锁和队列，并将它们传递给进程池：

（帮助函数make_iterator在这篇文章的底部给出。）条件 1 失败，RuntimeError: Lock objects should only be shared between processes through inheritance.

条件 2 非常相似，但现在锁和队列在管理器的监督下：

在条件 3 中，手动启动新进程，并且在没有管理器的情况下创建锁和队列：

条件 4 类似，但现在再次使用管理器：

在这两种情况下 - 3 和 4 - 我为 10 个任务中的每一个启动一个新进程，the_job其中最多ncores进程同时运行。这是通过以下辅助函数实现的：

结果

只有条件 1 失败 ( RuntimeError: Lock objects should only be shared between processes through inheritance) 而其他 3 个条件成功。我试着绕开这个结果。

为什么池需要在所有进程之间共享锁和队列，但条件 3 中的各个进程不需要？

我所知道的是，对于池条件（1 和 2），来自迭代器的所有数据都是通过酸洗传递的，而在单进程条件（3 和 4）中，来自迭代器的所有数据都是通过从主进程继承来传递的（我是使用Linux）。我想在从子进程中更改内存之前，会访问父进程使用的相同内存（写时复制）。但是一旦有人说lock.acquire()，这应该改变并且子进程确实使用放置在内存中其他地方的不同锁，不是吗？一个子进程如何知道一个兄弟激活了一个不是通过管理器共享的锁？

最后，有点相关的是我的问题 3 和 4 有多少不同。两者都有单独的流程，但它们在管理器的使用上有所不同。两者都被认为是有效代码吗？或者如果实际上不需要经理，是否应该避免使用经理？

完整脚本

对于那些只想复制和粘贴所有内容来执行代码的人，这里是完整的脚本：

I have a python script which is something like that:

what is the best way to call each of the os.system calls on different processor? using subprocess or multiprocessing pool?

NOTE : each run of the program will generate an output file.

I have this code :

and this code :

The external_function initializes an external programs by creating the necessary sub-directories in the directory found in the environment variable HOME. This function does this work only once in each process.

With the first example, which uses os.fork(), the directories are created as expected. But with second example, which uses multiprocessing, only the directories in rep2 get created.

Why isn't the second example creating directories in both rep1 and rep2?

我开发了一个带有Pool和map函数的多处理 python 脚本。它使用 Numpy。有趣的是，即使在我的计算机中使用单个进程池它也会冻结（在两个[20000, 36]暗矩阵的点积上，当然一个是转置的）并且它可以在我的远程服务器上正常运行而没有任何缺陷。但是，如果代码是顺序的（没有 Map 功能），它也可以在我的计算机上运行。

与我的计算机相比，服务器的内存非常大。我认为问题出在内存上，只尝试单个进程池，它又冻结了。此外，正如我从系统监视器中观察到的，内存指示器没有溢出。甚至单个进程池也会冻结。如果我在没有池的情况下按顺序运行相同的功能，它就可以正常工作。

关于如何追踪问题或可能是什么原因的任何想法？

我的电脑有 python 2.7.6，服务器有 2.7.5。如果有已知的错误，请指导我。两台机器都在 Ubuntu 上。

我是 python 新手，我正在尝试并行扩展我的处理。我有一个包含一定数量元组的文件，每个元组在最后一列中都有一定的值。我想拆分此文件数据并将我的函数并行应用于每个块。但问题是根据最后一列的值将数据分成块，并为每个块应用函数。例如，最后一列可能有一些元组的“a”和一些元组的“b”和一些的“c”。所以在那种情况下，我应该得到三个块并并行处理它。最后一列中唯一值的数量可能会因数据集而异，因此我需要相应地使用 CPU。

Q1：到目前为止，我尝试的是读取文件并根据该记录创建一个字典，因此上述一个基本上是三个键值对，一个以“a”为键，所有记录以“a”为值和与“b”和“c”相同。我可以在多处理中使用块大小，但这里它不是大小，它基于键，那么我该如何实现呢？

Q2：在处理完上述块后，我需要所有的输出，顺序无关紧要，然后我需要使用整个输出进行进一步处理，我怎样才能让我的主程序等到所有这些处理完成？

让我知道是否需要进一步输入。谢谢。

我正在执行以下代码并且它工作正常，但它不会产生到不同的进程，而是有时都在同一个进程中运行，有时是一种进程中的二合一。我正在使用4 cpu机器。这段代码有什么问题？

结果是

有时像这样，

有时，

我的问题是，它在什么基础上将功能分配给工人？我正在编写代码，它根据我的字典中的键数来决定进程的数量（考虑到我的数据总是比我的 CPU 有更少的键）。我的代码将开始 - 主代码读取文件并使用单个进程从中制作字典，并将其分支到并发进程的数量并等待它们处理数据（我正在使用 pool.map ），然后一旦获得子进程的结果，它就会开始处理它们。我怎样才能实现这个父等待子进程步骤？