1

我遇到了 python 多处理池类的一些意外行为。

以下是我的问题：
1) Pool 何时创建其上下文，稍后用于序列化？
只要在 Container 定义之后创建 Pool 对象，下面的示例就可以正常运行。如果交换池初始化，则会发生序列化错误。在我的生产代码中，我想在定义容器类之前初始化 Pool 方式。是否可以刷新池“上下文”或以其他方式实现此目的。
2) Pool 是否有自己的负载平衡机制，如果有，它是如何工作的？
如果我在具有 8 个进程池的 i7 机器上运行类似的示例，我会得到以下结果：
- 对于轻量级评估函数，Pool 倾向于仅使用一个进程进行计算。它根据要求创建了 8 个进程，但大多数时候只使用一个（我从内部打印了 pid，并且在 htop 中也看到了这个）。
- 对于繁重的评估函数，行为符合预期。它平等地使用所有 8 个进程。
3) 使用 Pool 时，我总是看到我请求的另外 4 个进程（即对于 Pool(processes=2)，我看到 6 个新进程）。他们的作用是什么？

我将 Linux 与 Python 2.7.2 一起使用

from multiprocessing import Pool
from datetime import datetime

POWER = 10

def eval_power(container):
    for power in xrange(2, POWER):
        container.val **= power
    return container

#processes = Pool(processes=2)

class Container(object):
    def __init__(self, value):
        self.val = value

processes = Pool(processes=2)

if __name__ == "__main__":
    cont = [Container(foo) for foo in xrange(20)]
    then = datetime.now()
    processes.map(eval_power, cont)
    now = datetime.now()
    print "Eval time:", now - then


编辑 - 对 BAKURIU
1) 我担心是这样的。
2）我不明白linux调度程序与python将计算分配给进程有什么关系。我的情况可以用下面的例子来说明：

from multiprocessing import Pool
from os import getpid
from collections import Counter


def light_func(ind):
    return getpid()


def heavy_func(ind):
    for foo in xrange(1000000):
        ind += foo
    return getpid()


if __name__ == "__main__":
    list_ = range(100)
    pool = Pool(4)
    l_func = pool.map(light_func, list_)
    h_func = pool.map(heavy_func, list_)

    print "light func:", Counter(l_func)
    print "heavy func:", Counter(h_func)


在我的 i5 机器（4 个线程）上，我得到以下结果：
light func: Counter({2967: 100})
Heavy func: Counter({2969: 28, 2967: 28, 2968: 23, 2970: 21})
看来情况正如我所描述的那样。但是我仍然不明白为什么python会这样做。我的猜测是它试图最小化通信费用，但它用于负载平衡的机制仍然未知。文档也不是很有帮助，多处理模块的文档记录很差。
3）如果我运行上面的代码，我会得到 4 个以上的进程，如前所述。画面来自htop：http: //i.stack.imgur.com/PldmM.png

4

1 回答 1

2

  1. 该Pool对象在调用期间创建子流程，__init__因此您必须在之前定义Container。顺便说一句，我不会将所有代码包含在一个文件中，而是使用一个模块来实现Container和其他实用程序，并编写一个启动主程序的小文件。

  2. Pool完全符合文档中的描述。特别是它无法控制进程的调度，因此您看到的是 Linux 的调度程序认为它是正确的。对于小型计算，它们花费的时间很短，以至于调度程序不会费心将它们并行化（由于核心亲和力等原因，这可能具有更好的性能）

  3. 您能否通过示例以及您在任务管理器中看到的内容来展示这一点？我认为它们可能是处理内部队列的进程Pool，但我不确定。在我的机器上，我只能看到主进程和两个子进程。

更新第 2 点：

该Pool对象只是将任务放入队列中，子进程从该队列中获取参数。如果一个进程几乎不需要时间来执行一个对象，那么 Linux 调度程序会让进程执行更多时间（因此从队列中消耗更多的项目）。如果执行需要很长时间，则此调度程序将更改进程，因此也会执行其他子进程。

在您的情况下，一个进程正在消耗所有项目，因为计算花费的时间非常短，以至于在其他子进程准备好之前它已经完成了所有项目。

正如我所说，Pool在平衡子流程的工作方面没有做任何事情。它只是一个队列和一堆工人，池将项目放入队列中，进程获取项目并计算结果。AFAIK 控制队列的唯一方法是将一定数量的任务放在队列中的单个项目中（请参阅文档），但不能保证哪个进程将获取哪个任务。其他一切都留给操作系统。

在我的机器上，结果没有那么极端。对于轻型计算，两个进程的调用数量大约是其他两个的两倍，而对于重型计算，它们的处理项目数量或多或少相同。可能在不同的操作系统和/或硬件上，我们会得到甚至不同的结果。

于 2013-04-20T10:36:56.637 回答