Python多处理似乎几乎不可能在类内/使用任何类实例进行。它的预期用途是什么？

我有一个ALOGRITHM，我正在尝试并行化，因为串行运行时间很长。但是，需要并行化的函数位于类内部<代码>多处理。池似乎是实现这一点的最佳和最快的方法，但存在一个问题。它的目标函数不能是对象实例的函数。意思是这样；您可以按以下方式声明

池

：

import multiprocessing as mp
cpus = mp.cpu_count()
poolCount = cpus*2
pool = mp.Pool(processes = poolCount, maxtasksperchild = 2)

然后实际使用它：

pool.map(self.TargetFunction, args)

但是这会引发一个错误，因为对象实例不能被pickle，就像

Pool

函数向其所有子进程传递信息一样。但是我必须使用

self.TargetFunction

因此我有了一个想法，我将创建一个名为

parallel

的新Python文件，只需编写几个函数，而不将它们放入类中，然后从我的原始类（我想并行化其函数）中调用这些函数

所以我试了一下：

import multiprocessing as mp

def MatrixHelper(args):
    WM = args[0][0]
    print(WM.CreateMatrixMp(*args))
    return WM.CreateMatrixMp(*args)

def Start(sigmaI, sigmaX, numPixels, WM):

    cpus = mp.cpu_count()
    poolCount = cpus * 2
    args = [(WM, sigmaI, sigmaX, i) for i in range(numPixels)]
    print('Number of cpu\'s to process WM:%d'%cpus)

    pool = mp.Pool(processes = poolCount, maxtasksperchild = 2)
    tempData = pool.map(MatrixHelper, args)

    return tempData

这些函数不是类的一部分，在

Pool

s

map

函数中使用

MatrixHelper

可以正常工作。但当我这么做的时候，我意识到这是没有出路的。需要并行化的函数（

CreateMatrixMp

）需要向其传递一个对象（声明为

def CreateMatrixMp（self，sigmaI，sigmaX，i）

）

因为它不是从类中调用的，所以它不会得到传递给它的

self

。为了解决这个问题，我将

Start

函数传递给调用对象本身。就像在中一样，我说

parallel.Start（sigmaI，sigmaX，self.numPixels，self）

。然后对象

self

变成

WM

，这样我就可以最终调用所需的函数

WM.CreateMatrixMp（）

我确信这是一种非常草率的编码方式，但我只是想看看它是否有效。但是没有，再次出现pickle错误，

map

函数根本无法处理任何对象实例

所以我的问题是，为什么它是这样设计的？它似乎毫无用处，在任何使用类的程序中都是完全不起作用的

我尝试使用

Process

而不是

Pool

，但这需要我最终编写的数组被共享，这需要进程彼此等待。如果我不希望它被共享，那么我让每个进程编写自己的较小数组，并在最后进行一次大的写入。但这两种情况都会导致运行时间比我连续运行时慢！Pythons内置的

多处理

似乎毫无用处

---

在我的tagret函数位于一个类中的情况下，有没有人能给我一些指导，告诉我如何通过多处理实际节省时间？我在这里的帖子上读到过使用

pathos.multi-processing

，但我在Windows上，与多个具有不同设置的人一起处理这个项目。让每个人都尝试安装它是不必要的。

多处理的本质是它产生子进程，这些子进程接收参数以运行某个函数。为了传递这些参数，它需要它们是可传递的：不排斥主进程、s.a.套接字、文件描述符和其他与操作系统相关的低级内容

这转化为“需要

pickle

able或serializable”

在同一主题上，并行处理在对问题进行自包含划分时效果最好。我可以告诉你想要共享某种输入/流/数据库源代码，但这可能会造成一个瓶颈，你必须在某个时候解决这个瓶颈（至少，从“python脚本”方面，而不是从“OS/数据库”方面。幸运的是，你现在必须尽早解决它

您可以重新编写类代码，以便在需要时而不是在开始时生成/创建这些不可拾取的资源

def targetFunction(self, range_params):
  if not self.ready():
    self._init_source()
  #rest of the code

您可以通过另一种方式解决问题（基于参数初始化对象）。是的，并行处理会带来成本

---

您可以查看，以获得关于这一问题的更透彻的见解。

我在尝试在类内使用多处理时遇到了类似的问题。我可以通过在线找到的一个相对简单的解决方法来解决它。基本上，您使用的是类外的函数，该函数在您尝试的函数内打开/解压方法下面是我发现的两个网站，它们解释了如何实现并行化

---

这是一篇旧文章，但在搜索主题时，它仍然是最重要的结果之一。有关此问题的一些好信息可以在堆栈溢出处找到：

您可以在此处找到答案：