Python多处理全局变量更新未返回到父级

Question

我试图从子进程返回值,但遗憾的是这些值是不可取消的.所以我在线程模块中使用了全局变量并且成功但在使用多处理模块时无法检索子进程中完成的更新.我希望我错过了一些东西.

最终打印的结果始终与给定vars dataDV03和dataDV04的初始值相同.子进程正在更新这些全局变量,但这些全局变量在父级中保持不变.

import multiprocessing

# NOT ABLE to get python to return values in passed variables.

ants = ['DV03', 'DV04']
dataDV03 = ['', '']
dataDV04 = {'driver': '', 'status': ''}


def getDV03CclDrivers(lib):  # call global variable
    global dataDV03
    dataDV03[1] = 1
    dataDV03[0] = 0

# eval( 'CCL.' + lib + '.' +  lib + '( "DV03" )' ) these are unpicklable instantiations

def getDV04CclDrivers(lib, dataDV04):   # pass global variable
    dataDV04['driver'] = 0  # eval( 'CCL.' + lib + '.' +  lib + '( "DV04" )' )


if __name__ == "__main__":

    jobs = []
    if 'DV03' in ants:
        j = multiprocessing.Process(target=getDV03CclDrivers, args=('LORR',))
        jobs.append(j)

    if 'DV04' in ants:
        j = multiprocessing.Process(target=getDV04CclDrivers, args=('LORR', dataDV04))
        jobs.append(j)

    for j in jobs:
        j.start()

    for j in jobs:
        j.join()

    print 'Results:\n'
    print 'DV03', dataDV03
    print 'DV04', dataDV04

我无法发布我的问题所以会尝试编辑原文.

这是不可拾取的对象:

In [1]: from CCL import LORR
In [2]: lorr=LORR.LORR('DV20', None)
In [3]: lorr
Out[3]: <CCL.LORR.LORR instance at 0x94b188c>

这是我使用multiprocessing.Pool将实例返回给父级时返回的错误:

Thread getCcl (('DV20', 'LORR'),)
Process PoolWorker-1:
Traceback (most recent call last):
File "/alma/ACS-10.1/casa/lib/python2.6/multiprocessing/process.py", line 232, in _bootstrap
self.run()
File "/alma/ACS-10.1/casa/lib/python2.6/multiprocessing/process.py", line 88, in run
self._target(*self._args, **self._kwargs)
File "/alma/ACS-10.1/casa/lib/python2.6/multiprocessing/pool.py", line 71, in worker
put((job, i, result))
File "/alma/ACS-10.1/casa/lib/python2.6/multiprocessing/queues.py", line 366, in put
return send(obj)
UnpickleableError: Cannot pickle <type 'thread.lock'> objects

Answer 1

当您multiprocessing用来打开第二个进程时,会创建一个全新的Python 实例,它具有自己的全局状态.不共享该全局状态,因此子进程对全局变量所做的更改对于父进程是不可见的.

此外,大多数multiprocessing提供使用pickle传输数据的抽象.使用代理传输的所有数据必须是可选择的 ; 其包括所有的一个对象Manager提供.相关引文(我的重点):

确保代理方法的参数是可选的.

(在本Manager节中):

其他进程可以使用代理访问共享对象.

Queue还需要可选择的数据; 文档没有这么说,但快速测试证实了这一点:

import multiprocessing
import pickle

class Thing(object):
    def __getstate__(self):
        print 'got pickled'
        return self.__dict__
    def __setstate__(self, state):
        print 'got unpickled'
        self.__dict__.update(state)

q = multiprocessing.Queue()
p = multiprocessing.Process(target=q.put, args=(Thing(),))
p.start()
print q.get()
p.join()

输出:

$ python mp.py 
got pickled
got unpickled
<__main__.Thing object at 0x10056b350>

如果您真的无法挑选数据,那么可能对您有用的一种方法是找到将其存储为ctype对象的方法; 然后可以将对存储器的引用传递给子进程.这对我来说似乎很狡猾; 我从来没有这样做过.但它可能是一个可能的解决方案.

鉴于您的更新,您似乎需要了解更多关于a的内部结构LORR.是LORR班级吗？你可以从中继承吗？它是其他东西的子类吗？什么是MRO？(LORR.__mro__如果它有效,请尝试并发布输出.)如果它是纯python对象,则可以对其进行子类化,创建a __setstate__和a __getstate__以启用酸洗.

另一种方法可能是弄清楚如何从LORR实例中获取相关数据并通过简单的字符串传递它.既然你说你真的只想调用对象的方法,那为什么不用Queues来回发送消息呢？换句话说,就像这样(示意性地):

Main Process              Child 1                       Child 2
                          LORR 1                        LORR 2 
child1_in_queue     ->    get message 'foo'
                          call 'foo' method
child1_out_queue    <-    return foo data string
child2_in_queue                   ->                    get message 'bar'
                                                        call 'bar' method
child2_out_queue                  <-                    return bar data string

Answer 2

@DBlas在答案中为您提供了一个快速的URL和对Manager类的引用,但我认为它仍然有点模糊,所以我认为它可能对您有用,只是看到它应用...

import multiprocessing
from multiprocessing import Manager

ants = ['DV03', 'DV04']

def getDV03CclDrivers(lib, data_dict):  
    data_dict[1] = 1
    data_dict[0] = 0

def getDV04CclDrivers(lib, data_list):   
    data_list['driver'] = 0  


if __name__ == "__main__":

    manager = Manager()
    dataDV03 = manager.list(['', ''])
    dataDV04 = manager.dict({'driver': '', 'status': ''})

    jobs = []
    if 'DV03' in ants:
        j = multiprocessing.Process(
                target=getDV03CclDrivers, 
                args=('LORR', dataDV03))
        jobs.append(j)

    if 'DV04' in ants:
        j = multiprocessing.Process(
                target=getDV04CclDrivers, 
                args=('LORR', dataDV04))
        jobs.append(j)

    for j in jobs:
        j.start()

    for j in jobs:
        j.join()

    print 'Results:\n'
    print 'DV03', dataDV03
    print 'DV04', dataDV04

因为多处理实际上使用单独的进程,所以不能简单地共享全局变量,因为它们将在内存中处于完全不同的"空格"中.你在一个过程中对全球所做的事情不会反映在另一个过程中.虽然我承认,从你看到它的方式看起来似乎令人困惑,但它们都存在于同一段代码中,所以"为什么这些方法不能进入全球"？更难以理解他们将在不同的流程中运行.

该经理类是给进程之间充当代理的数据结构可以穿梭信息来回你.你要做的是从经理创建一个特殊的字典和列表,将它们传递给你的方法,并在本地操作它们.

不可剔除的数据

对于您的specialized LORR对象,您可能需要创建类似代理的东西,该代理可以表示实例的可选状态.

不是超级强大或测试很多,但给你的想法.

class LORRProxy(object):

    def __init__(self, lorrObject=None):
        self.instance = lorrObject

    def __getstate__(self):
        # how to get the state data out of a lorr instance
        inst = self.instance
        state = dict(
            foo = inst.a,
            bar = inst.b,
        )
        return state

    def __setstate__(self, state):
        # rebuilt a lorr instance from state
        lorr = LORR.LORR()
        lorr.a = state['foo']
        lorr.b = state['bar']
        self.instance = lorr

Answer 3

使用时multiprocess,在进程之间传递对象的唯一方法是使用Queue或Pipe; 全局变量不共享.对象必须是pickleable,所以multiprocess在这里不会帮助你.

Answer 4

您还可以使用多处理 Array。这允许您在进程之间共享状态，并且可能是最接近全局变量的东西。

在 main 的顶部，声明一个数组。第一个参数 'i' 表示它将是整数。第二个参数给出初始值：

shared_dataDV03 = multiprocessing.Array ('i', (0, 0)) #a shared array

然后将此数组作为参数传递给进程：

j = multiprocessing.Process(target=getDV03CclDrivers, args=('LORR',shared_dataDV03))

您必须在被调用的函数中接收数组参数，然后您可以在函数内修改它：

def getDV03CclDrivers(lib,arr):  # call global variable
    arr[1]=1
    arr[0]=0

该数组与父级共享，因此您可以打印出父级末尾的值：

print 'DV03', shared_dataDV03[:]

它将显示更改：

DV03 [0, 1]