在多处理apply_async

Question

我希望，如果我在实例方法中调用apply_async并得到其结果，所做的任何更改将保留在分支过程的一部分。但是，似乎每个对apply_async的新调用都会创建该实例的新副本。

采用以下代码：

from multiprocessing.pool import Pool


class Multitest:
    def __init__(self):
        self.i = 0

    def run(self):
        with Pool(2) as pool:
            worker_jobs = []
            for j in range(10):
                job = pool.apply_async(self.process, (j,))
                worker_jobs.append(job)

            for job in worker_jobs:
                res = job.get()
                print("input", res)

    def process(self, inp):
        print("i", self.i)
        self.i += 1

        return inp

if __name__ == '__main__':
    mt = Multitest()
    mt.run()

样本输出：

i 0
i 0
i 0
i 0
i 0
input 0
i 0
i 0
i 0
i 0
i 0
input 1
input 2
input 3
input 4
input 5
input 6
input 7
input 8
input 9

但是，由于我们有两个可扩展10个输入的核心，因此我曾期望i属性会增加。

我期望以下流程：

• 主线程创建实例并调用run()
• 主线程通过初始化两个新进程和原始Multitest实例（其中apply_async的副本）在池中分配i = 0的工作
在新进程上多次调用
• process()（直到range()用完为止）。在每次调用流程时，该流程的self.i都会增加

注意：我不是询问两个进程之间的共享状态。相反，我在问为什么单个进程的类实例不发生突变（为什么每个单独进程的self.i都没有增加）。

但是，我没有看到这种行为。相反，打印输出仅为零，表明我的期望是错误的：状态（属性i）未维护，但是每次调用{{时，都会创建一个新实例（或至少一个新副本） 1}}。我在这里想念的是什么？如何使这项工作按预期进行？ （最好使用apply_async，尽管不是必需的。但是，应保持结果的顺序。）

据我所知，这种行为不仅针对apply_async，而且还针对其他apply_async方法。我有兴趣学习为什么发生这种情况以及如何将该行为更改为我想要实现的行为。赏金归功于可以为两个查询提供答案的答案。

Answer 1

我想为您提供参考，但我还没有任何参考，因此我将基于经验证据分享我的想法：

每次调用apply_async都会准备一个新的命名空间副本。您可以通过在流程内部添加对print(self)的调用来查看此内容。所以这部分是不正确的：

主线程通过初始化两个新进程来分配工作。 原始Multitest实例的副本

相反，原始的Multitest实例有两个新进程和 ten 副本。所有这些副本都是从主过程制作的，该主过程的i副本没有增加。为了演示这一点，请在对apply_async的调用之前添加time.sleep(1); self.i += 1，并注意a）主线程中i的值增加，并且b）通过延迟for循环，原始Multitest实例已更改了时间。下一次对apply_async的调用会触发一个新副本。

代码：

from multiprocessing.pool import Pool
import time

class Multitest:
    def __init__(self):
        print("Creating new Multitest instance: {}".format(self))
        self.i = 0

    def run(self):
        with Pool(2) as pool:
            worker_jobs = []
            for j in range(4):
                time.sleep(1); self.i += 1
                job = pool.apply_async(self.process, (j,))
                worker_jobs.append(job)

            for job in worker_jobs:
                res = job.get()
                print("input", res)

    def process(self, inp):
        print("i", self.i)
        print("Copied instance: {}".format(self))
        self.i += 1

        return inp

if __name__ == '__main__':
    mt = Multitest()
    mt.run()

结果：

Creating new Multitest instance: <__main__.Multitest object at 0x1056fc8b0>
i 1
Copied instance: <__mp_main__.Multitest object at 0x101052d90>
i 2
Copied instance: <__mp_main__.Multitest object at 0x101052df0>
i 3
Copied instance: <__mp_main__.Multitest object at 0x101052d90>
input 0
input 1
input 2
i 4
Copied instance: <__mp_main__.Multitest object at 0x101052df0>
input 3

关于第二个查询，我认为如果要在一个流程中维护状态，则可能只需要提交一份工作。您可以让Pool（2）处理2个独立的作业，而不是Pool（2）处理10个独立的作业，每个作业都包含5个相互依赖的子作业。另外，如果您确实需要10个作业，则可以使用由pid索引的共享数据结构，这样，在单个进程中按顺序运行的所有作业都可以操纵i的单个副本。

这是一个具有共享数据结构的示例，其形式为模块中的全局变量：

from multiprocessing.pool import Pool
from collections import defaultdict
import os
import myglobals # (empty .py file)

myglobals.i = defaultdict(lambda:0)

class Multitest:
    def __init__(self):
        pid = os.getpid()
        print("Creating new Multitest instance: {}".format(self))
        print("i {} (pid: {})".format(myglobals.i[pid], pid))

    def run(self):
        with Pool(2) as pool:
            worker_jobs = []
            for j in range(4):
                job = pool.apply_async(self.process, (j,))
                worker_jobs.append(job)

            for job in worker_jobs:
                res = job.get()
                print("input", res)

    def process(self, inp):
        pid = os.getpid()
        print("Copied instance: {}".format(self))
        print("i {} (pid: {})".format(myglobals.i[pid], pid))
        myglobals.i[pid] += 1

        return inp

if __name__ == '__main__':
    mt = Multitest()
    mt.run()

结果：

Creating new Multitest instance: <__main__.Multitest object at 0x1083f3880>
i 0 (pid: 3460)
Copied instance: <__mp_main__.Multitest object at 0x10d89cdf0>
i 0 (pid: 3463)
Copied instance: <__mp_main__.Multitest object at 0x10d89ce50>
Copied instance: <__mp_main__.Multitest object at 0x10550adf0>
i 0 (pid: 3462)
Copied instance: <__mp_main__.Multitest object at 0x10550ae50>
i 1 (pid: 3462)
i 1 (pid: 3463)
input 0
input 1
input 2
input 3

此技术来自https://stackoverflow.com/a/1676328/361691

Answer 2

我相信正在发生以下事情：

1. 每次调用self.process时，该方法都会被序列化（腌制）并发送给子进程。每次都会创建一个新副本。
2. 该方法在子流程中运行，但是由于它是单独副本的一部分，与父流程中的原始副本不同，因此其更改状态不会并且不会影响父流程。传回的唯一信息是返回值（也被腌制）。

请注意，子进程没有自己的Multitest实例，因为它仅在__name__ == '__main__'时创建，而该实例不适用于池创建的派生。

如果要在子进程中维护状态，可以使用全局变量来完成。创建池以初始化此类变量时，可以传递一个初始化器参数。

以下显示了您想要的工作版本（但没有OOP，这不适用于多处理）：

from multiprocessing.pool import Pool


def initialize():
    global I
    I = 0


def process(inp):
    global I
    print("I", I)
    I += 1
    return inp


if __name__ == '__main__':
    with Pool(2, initializer=initialize) as pool:
        worker_jobs = []
        for j in range(10):
            job = pool.apply_async(process, (j,))
            worker_jobs.append(job)

        for job in worker_jobs:
            res = job.get()
            print("input", res)

Answer 3

多处理和线程之间的一个区别是，在创建一个进程之后，它使用的内存实际上是从其父进程克隆而来的，因此进程之间没有共享内存。

这里是一个例子：

import os
import time
from threading import Thread

global_counter = 0

def my_thread():
    global global_counter
    print("in thread, global_counter is %r, add one." % global_counter)
    global_counter += 1

def test_thread():
    global global_counter
    th = Thread(target=my_thread)
    th.start()
    th.join()
    print("in parent, child thread joined, global_counter is %r now." % global_counter)

def test_fork():
    global global_counter
    pid = os.fork()
    if pid == 0:
        print("in child process, global_counter is %r, add one." % global_counter)
        global_counter += 1
        exit()
    time.sleep(1)
    print("in parent, child process died, global_counter is still %r." % global_counter)

def main():
    test_thread()
    test_fork()

if __name__ == "__main__":
    main()

输出：

in thread, global_counter is 0, add one.
in parent, child thread joined, global_counter is 1 now.
in child process, global_counter is 1, add one.
in parent, child process died, global_counter is still 1.

在您的情况下：

for j in range(10):
    # Before fork, self.i is 0, fork() dups memory, so the variable is not shared to the child.
    job = pool.apply_async(self.process, (j,))
    # After job finishes, child's self.i is 1 (not parent's), this variable is freed after child dies.
    worker_jobs.append(job)

编辑：

在python3酸洗中，绑定方法也将包括对象本身，本质上是将其复制。因此，每次调用apply_async时，对象self也会被腌制。

import os
from multiprocessing.pool import Pool
import pickle

class Multitest:
    def __init__(self):
        self.i = "myattr"

    def run(self):
        with Pool(2) as pool:
            worker_jobs = []
            for j in range(10):
                job = pool.apply_async(self.process, (j,))
                worker_jobs.append(job)

            for job in worker_jobs:
                res = job.get()
                print("input", res)

    def process(self, inp):
        print("i", self.i)
        self.i += "|append"

        return inp

def test_pickle():
    m = Multitest()
    print("original instance is %r" % m)

    pickled_method = pickle.dumps(m.process)
    assert b"myattr" in pickled_method

    unpickled_method = pickle.loads(pickled_method)
    # get instance from it's method (python 3)
    print("pickle duplicates the instance, new instance is %r" % unpickled_method.__self__)

if __name__ == '__main__':
    test_pickle()

输出：

original instance is <__main__.Multitest object at 0x1072828d0>
pickle duplicates the instance, new instance is <__main__.Multitest object at 0x107283110>