我正在尝试从子进程返回值，但遗憾的是这些值是不可取消的。所以我在线程模块中使用了全局变量并且成功但在使用多处理模块时无法检索子进程中完成的更新。我希望我错过了什么。
结尾处打印的结果始终与给定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
In [5]: dir(lorr)
Out[5]:
['GET_AMBIENT_TEMPERATURE',
'GET_CAN_ERROR',
'GET_CAN_ERROR_COUNT',
'GET_CHANNEL_NUMBER',
'GET_COUNT_PER_C_OP',
'GET_COUNT_REMAINING_OP',
'GET_DCM_LOCKED',
'GET_EFC_125_MHZ',
'GET_EFC_COMB_LINE_PLL',
'GET_ERROR_CODE_LAST_CAN_ERROR',
'GET_INTERNAL_SLAVE_ERROR_CODE',
'GET_MAGNITUDE_CELSIUS_OP',
'GET_MAJOR_REV_LEVEL',
'GET_MINOR_REV_LEVEL',
'GET_MODULE_CODES_CDAY',
'GET_MODULE_CODES_CMONTH',
'GET_MODULE_CODES_DIG1',
'GET_MODULE_CODES_DIG2',
'GET_MODULE_CODES_DIG4',
'GET_MODULE_CODES_DIG6',
'GET_MODULE_CODES_SERIAL',
'GET_MODULE_CODES_VERSION_MAJOR',
'GET_MODULE_CODES_VERSION_MINOR',
'GET_MODULE_CODES_YEAR',
'GET_NODE_ADDRESS',
'GET_OPTICAL_POWER_OFF',
'GET_OUTPUT_125MHZ_LOCKED',
'GET_OUTPUT_2GHZ_LOCKED',
'GET_PATCH_LEVEL',
'GET_POWER_SUPPLY_12V_NOT_OK',
'GET_POWER_SUPPLY_15V_NOT_OK',
'GET_PROTOCOL_MAJOR_REV_LEVEL',
'GET_PROTOCOL_MINOR_REV_LEVEL',
'GET_PROTOCOL_PATCH_LEVEL',
'GET_PROTOCOL_REV_LEVEL',
'GET_PWR_125_MHZ',
'GET_PWR_25_MHZ',
'GET_PWR_2_GHZ',
'GET_READ_MODULE_CODES',
'GET_RX_OPT_PWR',
'GET_SERIAL_NUMBER',
'GET_SIGN_OP',
'GET_STATUS',
'GET_SW_REV_LEVEL',
'GET_TE_LENGTH',
'GET_TE_LONG_FLAG_SET',
'GET_TE_OFFSET_COUNTER',
'GET_TE_SHORT_FLAG_SET',
'GET_TRANS_NUM',
'GET_VDC_12',
'GET_VDC_15',
'GET_VDC_7',
'GET_VDC_MINUS_7',
'SET_CLEAR_FLAGS',
'SET_FPGA_LOGIC_RESET',
'SET_RESET_AMBSI',
'SET_RESET_DEVICE',
'SET_RESYNC_TE',
'STATUS',
'_HardwareDevice__componentName',
'_HardwareDevice__hw',
'_HardwareDevice__stickyFlag',
'_LORRBase__logger',
'__del__',
'__doc__',
'__init__',
'__module__',
'_devices',
'clearDeviceCommunicationErrorAlarm',
'getControlList',
'getDeviceCommunicationErrorCounter',
'getErrorMessage',
'getHwState',
'getInternalSlaveCanErrorMsg',
'getLastCanErrorMsg',
'getMonitorList',
'hwConfigure',
'hwDiagnostic',
'hwInitialize',
'hwOperational',
'hwSimulation',
'hwStart',
'hwStop',
'inErrorState',
'isMonitoring',
'isSimulated']
In [6]:
答案 0 :(得分：33)
当您使用multiprocessing打开第二个进程时，会创建一个具有自己全局状态的Python的全新实例。不共享该全局状态，因此子进程对全局变量所做的更改对于父进程是不可见的。
此外，multiprocessing提供的大部分抽象都使用pickle来传输数据。使用代理must be pickleable传输的所有数据;包括Manager provides的所有对象。相关引文（我的重点）：
确保代理方法的参数可以选择。
和（在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对象;然后，对内存的引用可以是passed to a child process。这对我来说似乎很狡猾;我从来没有这样做过。但它可能是一个可能的解决方案。
鉴于您的更新，您似乎需要了解更多关于LORR内部的信息。 LORR是一类吗？你可以从中继承吗？它是其他东西的子类吗？什么是MRO？ （尝试LORR.__mro__并发布输出（如果有效）。）如果它是纯python对象，则可以对其进行子类化，创建__setstate__和__getstate__以启用酸洗。 / p>
另一种方法可能是弄清楚如何从LORR实例中获取相关数据并通过简单字符串传递它。既然你说你真的只想调用对象的方法，为什么不使用Queue s来回发送消息呢？换句话说，就像这样（示意性地）：
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
答案 1 :(得分：6)
@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
因为多处理实际上使用单独的进程，所以不能简单地共享全局变量，因为它们将在内存中处于完全不同的“空格”中。你在一个过程中对全球所做的事情不会反映在另一个过程中。虽然我承认，从你看到它的方式看起来似乎令人困惑，但它们都存在于同一段代码中，所以“为什么这些方法不能进入全球”？更难以理解他们将在不同的流程中运行。
Manager class用作数据结构的代理，可以在进程之间来回传递信息。你要做的是从经理创建一个特殊的字典和列表，将它们传递给你的方法，并在本地操作它们。
无法发布的数据
对于您的specialize 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
答案 2 :(得分：5)
使用multiprocess时，在流程之间传递对象的唯一方法是使用Queue或Pipe;全局变量不共享。对象必须是可选择的，因此multiprocess在这里不会帮助你。
答案 3 :(得分：4)
您还可以使用multiprocessing Array。这允许您在进程之间拥有共享状态，并且可能是与全局变量最接近的事物。
在main的顶部，声明一个Array。第一个参数'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]
答案 4 :(得分：1)
我使用p.map（）将大量进程分离到远程服务器，并在不可预测的时间返回时打印结果：
Servers=[...]
from multiprocessing import Pool
p=Pool(len(Servers))
p.map(DoIndividualSummary, Servers)
如果DoIndividualSummary使用print作为结果，则此工作正常，但总体结果是不可预测的顺序，这使解释变得困难。我尝试了许多方法来使用全局变量，但遇到了问题。最后，我用sqlite3成功了。
在p.map()之前，打开一个sqlite连接并创建一个表：
import sqlite3
conn=sqlite3.connect('servers.db') # need conn for commit and close
db=conn.cursor()
try: db.execute('''drop table servers''')
except: pass
db.execute('''CREATE TABLE servers (server text, serverdetail text, readings text)''')
conn.commit()
然后，从DoIndividualSummary()返回时，将结果保存到表格中：
db.execute('''INSERT INTO servers VALUES (?,?,?)''', (server,serverdetail,readings))
conn.commit()
return
在map()语句后，打印结果：
db.execute('''select * from servers order by server''')
rows=db.fetchall()
for server,serverdetail,readings in rows: print serverdetail,readings
似乎有点矫枉过正，但对我来说比推荐的解决方案更简单。
答案 5 :(得分：1)
进行并发编程时，建议不要使用共享状态。使用多个进程时尤其如此。
但是，如果您确实确实需要使用一些共享数据，那么多处理可以提供一种方法：
共享内存：
可以使用“值”或“数组”将数据存储在共享内存映射中。例如，以下代码：
from multiprocessing import Process, Value, Array
def f(n, a):
n.value = 3.1415927
for i in range(len(a)):
a[i] = -a[i]
if __name__ == '__main__':
num = Value('d', 0.0)
arr = Array('i', range(10))
p = Process(target=f, args=(num, arr))
p.start()
p.join()
print(num.value)
print(arr[:])`
将打印：
3.1415927
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
希望这会有所帮助。