Python 子流程中的多处理类

我想在类中使用python的多处理模块，它本身使用子进程来不阻止主调用

最简单的示例如下所示：

import multiprocessing as mp


class mpo():

def __init__(self):
    cpu = mp.cpu_count()
    self.Pool = mp.Pool(processes = 2)
    self.alive = True
    self.p = mp.Process(target = self.sub,args=())

def worker():
    print 'Alive'

def sub(self):
    print self.alive

    for i in range(2):
        print i
        self.Pool.apply_async(self.worker, args=())
    print 'done'
    self.Pool.close()
#   self.Pool.join()

我注释掉了最后一行，因为它引发了断言错误（只能加入子进程）。 当我这样做时：

m =mpo()
m.p.start()

输出是

True
0
1
done

我的主要问题是，为什么工作线程中的print语句从未到达

更新：

更新后的代码如下所示

import multiprocessing as mp


class mpo():

    def __init__(self):
        cpu = mp.cpu_count()
        self.alive = True
        self.p = mp.Process(target = self.sub,args=())
        self.result=[]

    def worker(self):
        self.result.append(1)
        print 'Alive'

    def sub(self):
        print self.alive
        Pool = mp.Pool(processes = 2)
        for i in range(2):
            print i
            Pool.apply_async(self.worker, args=())
        print 'done'
        Pool.close()
        Pool.join()

---

该池现在不必继承，因为它是在子流程中创建的。结果不是print语句，而是附加到调用对象，并且池被正确连接。然而，没有结果出现。

因此我认为这可能对应于您正在寻找的一个简单示例：

import multiprocessing as mp

def worker(arg):
    #print 'Alive'+str(arg)
    return "Alive and finished {0}".format(arg)

class mpo():
    def __init__(self):
        cpu = mp.cpu_count()
        self.alive = True
        self.pool = mp.Pool(processes = 2)
    def sub(self,arguments):
        self.results=self.pool.map_async(worker, arguments)
        return self.results

if __name__=="__main__":
    s=mpo()
    s.sub(range(10))
    print s.results.get()

另外你可以打电话

self.results.ready()

了解流程是否已完成其工作。您不必将其放入另一个进程中，因为map\u异步调用不会阻塞程序的其余部分

编辑： 关于您的评论，我并不认为将计算放在单独的进程中有什么价值，因为函数已经在单独的进程（池中）中运行。您只能通过将其嵌套在另一个子流程中来增加复杂性，但这是可能的：

import multiprocessing as mp
def worker(arg):
    #print 'Alive'+str(arg)
    return "Alive and finished {0}".format(arg)
class mpo():
    def __init__(self):
        cpu = mp.cpu_count()
        self.alive = True
        self.pool = mp.Pool(processes = 2)
    def sub(self,arguments):
        self.results=self.pool.map_async(worker, arguments)
        return self.results
def run_calculation(q):
    s=mpo()
    results=s.sub(range(10))
    q.put(results.get())

queue=mp.Queue()
proc=mp.Process(target=run_calculation,args=(queue,))
proc.start()
proc.join()
queue.get()

---

因此，我认为这可能对应于一个简单的例子，说明你在寻找什么：

import multiprocessing as mp

def worker(arg):
    #print 'Alive'+str(arg)
    return "Alive and finished {0}".format(arg)

class mpo():
    def __init__(self):
        cpu = mp.cpu_count()
        self.alive = True
        self.pool = mp.Pool(processes = 2)
    def sub(self,arguments):
        self.results=self.pool.map_async(worker, arguments)
        return self.results

if __name__=="__main__":
    s=mpo()
    s.sub(range(10))
    print s.results.get()

另外你可以打电话

self.results.ready()

了解流程是否已完成其工作。您不必将其放入另一个进程中，因为map\u异步调用不会阻塞程序的其余部分

编辑： 关于您的评论，我并不认为将计算放在单独的进程中有什么价值，因为函数已经在单独的进程（池中）中运行。您只能通过将其嵌套在另一个子流程中来增加复杂性，但这是可能的：

import multiprocessing as mp
def worker(arg):
    #print 'Alive'+str(arg)
    return "Alive and finished {0}".format(arg)
class mpo():
    def __init__(self):
        cpu = mp.cpu_count()
        self.alive = True
        self.pool = mp.Pool(processes = 2)
    def sub(self,arguments):
        self.results=self.pool.map_async(worker, arguments)
        return self.results
def run_calculation(q):
    s=mpo()
    results=s.sub(range(10))
    q.put(results.get())

queue=mp.Queue()
proc=mp.Process(target=run_calculation,args=(queue,))
proc.start()
proc.join()
queue.get()

---

因此，我认为这可能对应于一个简单的例子，说明你在寻找什么：

import multiprocessing as mp

def worker(arg):
    #print 'Alive'+str(arg)
    return "Alive and finished {0}".format(arg)

class mpo():
    def __init__(self):
        cpu = mp.cpu_count()
        self.alive = True
        self.pool = mp.Pool(processes = 2)
    def sub(self,arguments):
        self.results=self.pool.map_async(worker, arguments)
        return self.results

if __name__=="__main__":
    s=mpo()
    s.sub(range(10))
    print s.results.get()

另外你可以打电话

self.results.ready()

了解流程是否已完成其工作。您不必将其放入另一个进程中，因为map\u异步调用不会阻塞程序的其余部分

编辑： 关于您的评论，我并不认为将计算放在单独的进程中有什么价值，因为函数已经在单独的进程（池中）中运行。您只能通过将其嵌套在另一个子流程中来增加复杂性，但这是可能的：

import multiprocessing as mp
def worker(arg):
    #print 'Alive'+str(arg)
    return "Alive and finished {0}".format(arg)
class mpo():
    def __init__(self):
        cpu = mp.cpu_count()
        self.alive = True
        self.pool = mp.Pool(processes = 2)
    def sub(self,arguments):
        self.results=self.pool.map_async(worker, arguments)
        return self.results
def run_calculation(q):
    s=mpo()
    results=s.sub(range(10))
    q.put(results.get())

queue=mp.Queue()
proc=mp.Process(target=run_calculation,args=(queue,))
proc.start()
proc.join()
queue.get()

---

因此，我认为这可能对应于一个简单的例子，说明你在寻找什么：

import multiprocessing as mp

def worker(arg):
    #print 'Alive'+str(arg)
    return "Alive and finished {0}".format(arg)

class mpo():
    def __init__(self):
        cpu = mp.cpu_count()
        self.alive = True
        self.pool = mp.Pool(processes = 2)
    def sub(self,arguments):
        self.results=self.pool.map_async(worker, arguments)
        return self.results

if __name__=="__main__":
    s=mpo()
    s.sub(range(10))
    print s.results.get()

另外你可以打电话

self.results.ready()

了解流程是否已完成其工作。您不必将其放入另一个进程中，因为map\u异步调用不会阻塞程序的其余部分

编辑： 关于您的评论，我并不认为将计算放在单独的进程中有什么价值，因为函数已经在单独的进程（池中）中运行。您只能通过将其嵌套在另一个子流程中来增加复杂性，但这是可能的：

import multiprocessing as mp
def worker(arg):
    #print 'Alive'+str(arg)
    return "Alive and finished {0}".format(arg)
class mpo():
    def __init__(self):
        cpu = mp.cpu_count()
        self.alive = True
        self.pool = mp.Pool(processes = 2)
    def sub(self,arguments):
        self.results=self.pool.map_async(worker, arguments)
        return self.results
def run_calculation(q):
    s=mpo()
    results=s.sub(range(10))
    q.put(results.get())

queue=mp.Queue()
proc=mp.Process(target=run_calculation,args=(queue,))
proc.start()
proc.join()
queue.get()

---

这个例子根本不适合我。我收到一个

未实现的错误：池对象无法在进程之间传递或从
进程.start（）
中pickle

。显然，它不喜欢将

池

发送到

进程

将池移动到子函数中不会改变这种行为。有几个问题（1）在子进程中继承池（2）调用

.join（）

（3）在工作进程中继承标准输出。你可以一个接一个地解决这些问题，但看起来像是.@J.F.Sebastian：你有解决这些问题的想法吗？实际上，我正在通过简单（手动）子处理解决原始问题。我只是想了解我发布的代码有什么问题，因为我想了解类、池和子进程的共存。让代码正常工作的最简单方法是使用不属于类的函数。在您的情况下，两个进程可能同时开始写入同一变量self.result，这是不允许的。此外，您似乎更需要map\u async而不是apply\u async，因为您希望多次执行相同的函数。查看中的示例，并始终将所使用的函数和变量分开。最后一件事：不要在异步中使用print语句。进程。这个例子根本不适合我。我收到一个

未实现的错误：池对象无法在进程之间传递或从
进程.start（）
中pickle

。显然，它不喜欢将

池

发送到

进程

将池移动到子函数中不会改变这种行为。有几个问题（1）在子进程中继承池（2）调用

.join（）

（3）在工作进程中继承标准输出。你可以一个接一个地解决这些问题，但看起来像是.@J.F.Sebastian：你有解决这些问题的想法吗？实际上，我正在通过简单（手动）子处理解决原始问题。我只是想了解我发布的代码有什么问题，因为我想了解类、池和子进程的共存。让代码正常工作的最简单方法是使用不属于类的函数。在您的情况下，两个进程可能同时开始写入同一变量self.result，这是不允许的。此外，您似乎更需要map\u async而不是apply\u async，因为您希望多次执行相同的函数。查看中的示例，并始终将所使用的函数和变量分开。最后一件事：不要在异步中使用print语句。进程。这个例子根本不适合我。我得到一个

未实现的错误：池对象不能在进程之间传递，也不能从
进程中pickle