问题标签 [multiprocessing]

随着最近关于多核编程的热议，有人在探索使用MPI的可能性吗？

我正在试验 Python 2.6 中的新多处理模块。我正在创建几个进程，每个进程都有自己的 multiprocessor.JoinableQueue 实例。每个进程产生一个或多个工作线程（threading.Thread 的子类），它们共享 JoinableQueue 实例（通过每个线程的__init__方法传入）。它似乎通常可以工作，但偶尔会出现无法预料的失败并出现以下错误：

我的 Queue get() 和 task_done() 调用紧随其后，因此它们应该相等。有趣的是，这似乎只有在 get() 和 task_done() 之间完成的工作非常快时才会发生。插入一个小的time.sleep(0.01)似乎可以缓解这个问题。

有什么想法吗？我可以使用带线程的多处理器队列而不是更传统的（Queue.Queue）吗？

谢谢！

-布赖恩

（我在这个例子中使用了pyprocessing模块，但是如果你运行python 2.6或者使用multiprocessing backport，用 multiprocessing 替换 processing 应该可以工作）

我目前有一个程序可以侦听 unix 套接字（使用 processing.connection.Listener），接受连接并生成一个处理请求的线程。在某个时刻，我想优雅地退出该过程，但由于 accept() 调用被阻塞，我看不出有什么办法可以很好地取消它。我至少有一种方法可以在这里工作（OS X），设置一个信号处理程序并从另一个线程发出进程信号，如下所示：

我想到的唯一另一种方法是深入连接（listener._listener._socket）并设置非阻塞选项......但这可能有一些副作用并且通常非常可怕。

有没有人有更优雅（甚至可能是正确的！）的方式来完成这个？它需要可移植到 OS X、Linux 和 BSD，但 Windows 可移植性等不是必需的。

澄清：谢谢大家！像往常一样，我原来的问题中的歧义被揭示了:)

• 我需要在取消监听后执行清理，并且我并不总是想真正退出该过程。
• 我需要能够从不是从同一个父进程产生的其他进程访问这个进程，这使得队列变得笨拙
• 线程的原因是：
  • 他们访问共享状态。实际上或多或少是一个常见的内存数据库，所以我想它可以做得不同。
  • 我必须能够同时接受多个连接，但实际线程大部分时间都在阻塞。每个接受的连接都会产生一个新线程；这是为了不阻止 I/O 操作上的所有客户端。

关于线程与进程，我使用线程来使我的阻塞操作非阻塞，并使用进程来启用多处理。

I have created a client-server program with Perl using IO::Socket::INET. I access server through CGI based site. My server program will run as daemon and will accept multiple simultaneous connections. My server process consumes about 100MB of memory space (9 large arrays, many arrays...). I want these hashes to reside in memory and share them so that I don't have to create them for every connection. Hash creation takes 10-15 seconds.

Whenever a new connection is accepted through sockets, I fork a new process to take care of the processing for each connection received. Since parent process is huge, every time I fork, processor tries to allocate memory to a new child, but due to limited memory, it takes large time to spawn a new child, thereby increasing the response time. Many times it hangs down even for a single connection.

Parent process creates 9 large hashes. For each child, I need to refer to one or more hashes in read-only mode. I will not update hashes through child. I want to use something like copy-on-write, by which I can share whole 100mb or whole global variables created by parent with all child? or any other mechanism like threads. I expect the server will get minimum 100 request per second and it should be able to process all of them in parallel. On an average, a child will exit in 2 seconds.

I am using Cygwin on Windows XP with only 1GB of RAM. I am not finding any way to overcome this issue. Can you suggest something? How can I share variables and also create 100 child processes per second and manage them and synchronize them,

Thanks.

我在使用 Python 多处理模块时遇到问题。我正在使用Process该类来生成一个新进程以利用我的第二个核心。第二个过程将一堆数据加载到 RAM 中，然后耐心等待而不是消耗。

我想看看这个过程用print命令打印了什么，但是，我没有看到它打印的任何东西。我只看到父进程打印的内容。现在这对我来说很有意义，因为他们生活在两个不同的过程中。第二个进程不会产生自己的 shell/标准输出窗口，也不会将其输出发送到父进程。然而，当这个进程崩溃时，它会打印我的脚本告诉它打印的所有内容，以及堆栈跟踪和错误。

我想知道是否有一种简单的方法可以将子进程的打印输出发送到第一个进程，或者让它产生一个 shell/标准输出，以便我可以调试它。我知道我可以创建一个multiprocessing.Queue专用于将打印传输到父级，以便它可以将这些打印到标准输出，但如果存在更简单的解决方案，我不想这样做。

我想在应用程序的其余部分继续运行时生成另一个进程以异步显示错误消息。

我正在使用multiprocessingPython 2.6 中的模块来创建进程，并尝试使用TKinter.

此代码在 Windows 上运行良好，但在 Linux 上运行它，TKinter如果我调用'showerror("MyApp Error", "Something bad happened.")'. 如果我通过直接调用在同一进程中运行它，它确实showerrorprocess会出现。鉴于此，它似乎TKinter工作正常。我可以打印到控制台并从 生成的进程中执行其他操作multiprocessing，因此它似乎也可以正常工作。

他们只是似乎没有一起工作。我需要做一些特别的事情来允许衍生的子进程创建窗口吗？

编辑

问题似乎TKinter是由父进程导入，并“继承”到子进程中，但不知何故，它的状态与父进程密不可分，无法在子进程中工作。只要您确保TKinter在生成子进程之前不导入，它就会起作用，因为这是第一次导入它的子进程。

如果我想让 Python 分布在多台计算机上的多个处理器上，我最好的方法是什么？如果我有 3 个八核服务器，那意味着我必须运行 24 个 python 进程。我将使用多处理库，并共享对象，看起来最好的主意是使用管理器。我希望所有节点作为一个大进程一起工作，所以一个管理器是理想的，但这会给我的服务器带来单点故障。有更好的解决方案吗？复制经理的对象存储是个好主意吗？

此外，如果经理要进行所有数据库查询，那么将它与数据库放在同一台机器上是否有意义？

现在我在一个框架中有一个中心模块，它使用 Python 2.6multiprocessing模块生成多个进程。因为它使用multiprocessing，所以有模块级多处理感知日志，LOG = multiprocessing.get_logger(). 根据文档，此记录器具有进程共享锁，因此您不会sys.stderr通过同时写入多个进程而在（或任何文件句柄）中乱码。

我现在遇到的问题是框架中的其他模块不支持多处理。在我看来，我需要让这个中央模块的所有依赖项都使用多处理感知日志记录。这在框架内很烦人，更不用说框架的所有客户端了。有没有我没有想到的替代方案？

通过多处理生成的子进程是否共享程序中先前创建的对象？

我有以下设置：

我正在将一些大对象加载到内存中，然后创建一个需要使用该大对象的工作人员池。大对象是只读访问的，我不需要在进程之间传递它的修改。

我的问题是：大对象是否加载到共享内存中，就像我在 unix/c 中生成一个进程一样，还是每个进程都加载自己的大对象副本？

更新：进一步澄清 - big_lookup_object 是一个共享查找对象。我不需要将其拆分并单独处理。我需要保留一份。我需要拆分它的工作是读取许多其他大文件并根据查找对象查找这些大文件中的项目。

进一步更新：数据库是一个很好的解决方案，memcached 可能是一个更好的解决方案，磁盘上的文件（搁置或 dbm）可能会更好。在这个问题中，我对内存解决方案特别感兴趣。对于最终解决方案，我将使用 hadoop，但我想看看我是否也可以拥有本地内存版本。

我正在为 Linux 设计一个专用的系统日志处理守护进程，它需要强大且可扩展，并且我正在讨论多线程与多进程。

多线程的明显反对意见是复杂性和讨厌的错误。由于 IPC 通信和上下文切换，多进程可能会影响性能。

“Unix 编程的艺术”在这里讨论了这一点。

您会推荐基于进程的系统（如 Apache）还是多线程方法？