Python多处理性能差

我试图使用多处理模块来加速我的python程序，但我发现它相当慢。 玩具示例如下所示：

import time
from multiprocessing import Pool, Manager

class A:
    def __init__(self, i):
        self.i = i

    def score(self, x):
        return self.i - x


class B:
    def __init__(self):
        self.i_list = list(range(1000))
        self.A_list = []

    def run_1(self):
        for i in self.i_list:
            self.x = i
            map(self.compute, self.A_list) #map version
            self.A_list.append(A(i))

    def run_2(self):
        p = Pool()
        for i in self.i_list:
            self.x = i
            p.map(self.compute, self.A_list) #multicore version
            self.A_list.append(A(i))

    def compute(self, some_A):
        return some_A.score(self.x)

if __name__ == "__main__":
    st = time.time()
    foo = B()
    foo.run_1()
    print("Map: ", time.time()-st)
    st = time.time()
    foo = B()
    foo.run_2()
    print("MultiCore: ", time.time()-st) 

在我的计算机（Windows 10、Python 3.5）上的结果是

地图：0.0009996891021728516

多核：19.34994912147522

在Linux机器（CentOS 7、Python 3.6）上也可以观察到类似的结果

我猜这是由进程间对象的酸洗/剥离引起的？我尝试使用Manager模块，但未能使其正常工作

任何帮助都将不胜感激。

哇，这真是令人印象深刻（而且很慢！）

是的，这是因为工作人员必须同时访问对象，这是非常昂贵的

因此，我玩了一点，并设法通过使计算方法保持静态来获得很多性能。因此，基本上，您不再需要共享B对象实例。仍然很慢，但更好

import time
from multiprocessing import Pool, Manager

class A:
    def __init__(self, i):
        self.i = i

    def score(self, x):
        return self.i - x

x=0
def static_compute(some_A):
    res= some_A.score(x)
    return res


class B:
    def __init__(self):
        self.i_list = list(range(1000))
        self.A_list = []

    def run_1(self):
        for i in self.i_list:
            x=i
            map(self.compute, self.A_list) #map version
            self.A_list.append(A(i))

    def run_2(self):
        p = Pool(4)
        for i in self.i_list:
            x=i
            p.map(static_compute, self.A_list) #multicore version
            self.A_list.append(A(i))

---

对我来说，另一个让它变慢的原因是使用池的固定成本。你实际上启动了一个Pool.map 1000次。如果启动这些流程有固定的成本，这将使总体战略缓慢。也许你应该用更长的i_列表（比i_列表长，需要不同的算法）来测试它。

这背后的原因是：

map调用由main执行

*这意味着调用foo.run_1（）时。main本身就是映射。 就像告诉自己该做什么一样

*调用foo_run2（）时，main映射该pc的最大进程容量。 如果最大进程数为6，则主进程映射为6个线程。 很像组织6个人来告诉你一些事情

旁注： 如果您使用：

p.imap(self.compute,self.A_list)

---

项目将按顺序添加到列表中，速度慢的不是

map

，而是

self.A\u list.append（A（i））

而且您似乎没有正确使用

map

。它返回一个值，而您根本不使用它。你知道地图正在做什么吗？谢谢你的评论。从第一次计时结果可以看出，

map

和

append

都很快。相反，

p.map

速度较慢（多处理版本）。我没有使用

map

的返回值，因为这只是显示

p.map

性能差的一个示例，我不需要返回值。谢谢。静态功能要快得多。我认为，尽管在本例中不引人注目，但它将有助于我的实际应用。