即使你封装了对象，多处理模块最终也会在每个进程中使用对象的本地副本，并且永远不会真正将你的更改传播回给你。在这种情况下，你没有正确使用 Pool.map，因为它期望每个方法调用都返回一个结果，然后将结果发送回你的返回值。如果你想要影响共享对象，那么你需要一个管理器来协调共享内存：

封装共享对象

from multiprocessing import Pool 
from multiprocessing import Manager
import sys

class encapsulation:
   def __init__(self):
       self.member_dict = {}
   def update_dict(self,index,value):
       self.member_dict[index] = value

encaps = encapsulation()

def method(argument):
   encaps.update_dict(argument,argument)
   # print encaps.member_dict       

manager = Manager()
encaps.member_dict = manager.dict()

p = Pool()
p.map(method,sys.argv[1:])

print encaps.member_dict

输出

$ python mp.py a b c
{'a': 'a', 'c': 'c', 'b': 'b'}

我建议不要真正将共享对象设置为成员属性，而是将其作为参数传入，或者封装共享对象本身，然后将其值传入字典。共享对象无法持久保存。它需要被清空并丢弃：

# copy the values to a reg dict
encaps.member_dict = encaps.member_dict.copy()

但这可能更好：

class encapsulation:
   def __init__(self):
       self.member_dict = {}
   # normal dict update
   def update_dict(self,d):
       self.member_dict.update(d)

encaps = encapsulation()

manager = Manager()
results_dict = manager.dict()

# pass in the shared object only
def method(argument):
   results_dict[argument] = argument    

p = Pool()
p.map(method,sys.argv[1:])

encaps.update_dict(results_dict)

按预期使用pool.map

如果您使用地图返回值，它可能看起来像这样：

def method(argument):
   encaps.update_dict(argument,argument)
   return encaps.member_dict

p = Pool()
results = p.map(method,sys.argv[1:]) 
print results
# [{'a': 'a'}, {'b': 'b'}, {'c': 'c'}]

您需要将结果再次合并到您的字典中：

for result in results:
    encaps.member_dict.update(result)
print encaps.member_dict
# {'a': 'a', 'c': 'c', 'b': 'b'}