多重处理:如何在多个流程之间共享一个字典?


113

一个程序,该程序创建在可连接队列上工作的多个进程Q,并且最终可能会操纵全局字典D来存储结果。(因此每个子进程都可以D用来存储其结果,并查看其他子进程正在产生什么结果)

如果我在子进程中打印字典D,我会看到对它进行的修改(即在D上)。但是在主流程加入Q之后,如果我打印D,那就是空洞的字典!

我了解这是同步/锁定问题。有人可以告诉我这里发生了什么,如何同步对D的访问?


1
至少在使用osx 10.14.4的python 3.7.2上,此方法无法正常工作。Dict未同步,其内容被其他进程重写。但是,<code> multiprocessing.Manager()。list()</ code>可以正常工作。
安德鲁·德拉琴科

Answers:


162

一般的答案涉及使用Manager对象。改编自文档:

from multiprocessing import Process, Manager

def f(d):
    d[1] += '1'
    d['2'] += 2

if __name__ == '__main__':
    manager = Manager()

    d = manager.dict()
    d[1] = '1'
    d['2'] = 2

    p1 = Process(target=f, args=(d,))
    p2 = Process(target=f, args=(d,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

    print d

输出:

$ python mul.py 
{1: '111', '2': 6}

4
谢谢senderle。确实,D = multiprocessing.Manager()。dict()解决了我的问题。我正在使用D = dict()。
dop

3
@LorenzoBelli,如果您要询问是否同步访问管理器,我相信答案是肯定的。multiprocessing.Manager()返回的实例SyncManager,该实例的名称表示相同!
senderle '17

@senderle我想与子进程共享父进程的numpy随机状态。我尝试使用,Manager但仍然没有运气。您能否在这里看看我的问题,看看是否可以提供解决方案?如果我np.random.seed(None)每次生成一个随机数时仍然可以得到不同的随机数,但是这不允许我使用父进程的随机状态,这不是我想要的。任何帮助是极大的赞赏。
阿米尔(Amir)

1
@RadioControlled很高兴写一个更新,但是简短地说,虽然我认为您不能直接做到这一点,但是您可以轻松地创建具有相同键和值的新托管字典,并使用它代替原始的。这样适合您的情况吗?
senderle

1
@senderle,这就是我最终要做的。因此,答案将是您必须这样做。
无线电控制的

25

多处理不像线程。每个子进程将获得主进程内存的副本。通常,状态是通过通信(管道/套接字),信号或共享内存共享的。

多重处理可为您的用例提供一些抽象-共享状态通过使用代理或共享内存被视为本地状态:http : //docs.python.org/library/multiprocessing.html#sharing-state-between-processes

相关章节:


1
非常感谢。您使我想到了一个解决方案:multiprocessing.Manager()。dict()。
dop

有人可以详细说明“每个子进程将获得主进程的内存副本”的意思吗?
Itsme2003年

默认情况下,@ Itsme2003产生的进程无法访问父进程的内存(这是线程的关键区别之一)。因此,当流程需要父流程的对象时,它必须创建它的副本(而不是获取对实际对象的引用)。上面的答案详细说明了如何在进程之间共享对象。
尼古拉斯·梅尔奇

因为这经常被误解:只要不修改对象,至少在通常的Linux安装程序中,对象实际上仅在内存中存储一​​次。更改后将立即复制它。如果您需要节省内存并且不修改对象,这可能非常重要。
无线电控制的

16

我想分享自己的工作,该工作比Manager的指令快,并且比使用大量内存并且不适用于Mac OS的pyshmht库更简单,更稳定。虽然我的字典仅适用于纯字符串,并且目前不可变。我使用线性探测实现,并将键和值对存储在表后的单独内存块中。

from mmap import mmap
import struct
from timeit import default_timer
from multiprocessing import Manager
from pyshmht import HashTable


class shared_immutable_dict:
    def __init__(self, a):
        self.hs = 1 << (len(a) * 3).bit_length()
        kvp = self.hs * 4
        ht = [0xffffffff] * self.hs
        kvl = []
        for k, v in a.iteritems():
            h = self.hash(k)
            while ht[h] != 0xffffffff:
                h = (h + 1) & (self.hs - 1)
            ht[h] = kvp
            kvp += self.kvlen(k) + self.kvlen(v)
            kvl.append(k)
            kvl.append(v)

        self.m = mmap(-1, kvp)
        for p in ht:
            self.m.write(uint_format.pack(p))
        for x in kvl:
            if len(x) <= 0x7f:
                self.m.write_byte(chr(len(x)))
            else:
                self.m.write(uint_format.pack(0x80000000 + len(x)))
            self.m.write(x)

    def hash(self, k):
        h = hash(k)
        h = (h + (h >> 3) + (h >> 13) + (h >> 23)) * 1749375391 & (self.hs - 1)
        return h

    def get(self, k, d=None):
        h = self.hash(k)
        while True:
            x = uint_format.unpack(self.m[h * 4:h * 4 + 4])[0]
            if x == 0xffffffff:
                return d
            self.m.seek(x)
            if k == self.read_kv():
                return self.read_kv()
            h = (h + 1) & (self.hs - 1)

    def read_kv(self):
        sz = ord(self.m.read_byte())
        if sz & 0x80:
            sz = uint_format.unpack(chr(sz) + self.m.read(3))[0] - 0x80000000
        return self.m.read(sz)

    def kvlen(self, k):
        return len(k) + (1 if len(k) <= 0x7f else 4)

    def __contains__(self, k):
        return self.get(k, None) is not None

    def close(self):
        self.m.close()

uint_format = struct.Struct('>I')


def uget(a, k, d=None):
    return to_unicode(a.get(to_str(k), d))


def uin(a, k):
    return to_str(k) in a


def to_unicode(s):
    return s.decode('utf-8') if isinstance(s, str) else s


def to_str(s):
    return s.encode('utf-8') if isinstance(s, unicode) else s


def mmap_test():
    n = 1000000
    d = shared_immutable_dict({str(i * 2): '1' for i in xrange(n)})
    start_time = default_timer()
    for i in xrange(n):
        if bool(d.get(str(i))) != (i % 2 == 0):
            raise Exception(i)
    print 'mmap speed: %d gets per sec' % (n / (default_timer() - start_time))


def manager_test():
    n = 100000
    d = Manager().dict({str(i * 2): '1' for i in xrange(n)})
    start_time = default_timer()
    for i in xrange(n):
        if bool(d.get(str(i))) != (i % 2 == 0):
            raise Exception(i)
    print 'manager speed: %d gets per sec' % (n / (default_timer() - start_time))


def shm_test():
    n = 1000000
    d = HashTable('tmp', n)
    d.update({str(i * 2): '1' for i in xrange(n)})
    start_time = default_timer()
    for i in xrange(n):
        if bool(d.get(str(i))) != (i % 2 == 0):
            raise Exception(i)
    print 'shm speed: %d gets per sec' % (n / (default_timer() - start_time))


if __name__ == '__main__':
    mmap_test()
    manager_test()
    shm_test()

在我的笔记本电脑上,性能结果是:

mmap speed: 247288 gets per sec
manager speed: 33792 gets per sec
shm speed: 691332 gets per sec

简单用法示例:

ht = shared_immutable_dict({'a': '1', 'b': '2'})
print ht.get('a')

13
Github?文档?我们如何使用这个工具?
Pavlos Panteliadis

10

除了这里的@senderle之外,有些人可能还想知道如何使用的功能multiprocessing.Pool

令人高兴的是,实例中有一个.Pool()方法可以manager模拟所有熟悉的顶层API multiprocessing

from itertools import repeat
import multiprocessing as mp
import os
import pprint

def f(d: dict) -> None:
    pid = os.getpid()
    d[pid] = "Hi, I was written by process %d" % pid

if __name__ == '__main__':
    with mp.Manager() as manager:
        d = manager.dict()
        with manager.Pool() as pool:
            pool.map(f, repeat(d, 10))
        # `d` is a DictProxy object that can be converted to dict
        pprint.pprint(dict(d))

输出:

$ python3 mul.py 
{22562: 'Hi, I was written by process 22562',
 22563: 'Hi, I was written by process 22563',
 22564: 'Hi, I was written by process 22564',
 22565: 'Hi, I was written by process 22565',
 22566: 'Hi, I was written by process 22566',
 22567: 'Hi, I was written by process 22567',
 22568: 'Hi, I was written by process 22568',
 22569: 'Hi, I was written by process 22569',
 22570: 'Hi, I was written by process 22570',
 22571: 'Hi, I was written by process 22571'}

这是一个稍有不同的示例,其中每个进程仅将其进程ID记录到全局DictProxy对象中d


3

也许您可以尝试pyshmht,为Python共享基于内存的哈希表扩展。

注意

  1. 尚未经过全面测试,仅供参考。

  2. 当前,它缺乏用于多处理的锁定/ sem机制。

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.