python - 多处理中的共享内存

Question

我有三个大列表。第一个包含位数组(模块位数组 0.8.0)，另外两个包含整数数组。

l1=[bitarray 1, bitarray 2, ... ,bitarray n]
l2=[array 1, array 2, ... , array n]
l3=[array 1, array 2, ... , array n]

这些数据结构需要相当多的 RAM(总共约 16GB)。

如果我使用以下方法启动 12 个子流程:

multiprocessing.Process(target=someFunction, args=(l1,l2,l3))

这是否意味着将为每个子进程复制 l1、l2 和 l3，还是子进程将共享这些列表？或者更直接地说，我会使用 16GB 还是 192GB 的 RAM？

someFunction 将从这些列表中读取一些值，然后根据读取的值执行一些计算。结果将返回给父进程。列表 l1、l2 和 l3 不会被 someFunction 修改。

因此，我假设子进程不需要也不会复制这些巨大的列表，而是与父进程共享它们。这意味着由于 linux 下的写时复制方法，该程序将占用 16GB 的 RAM(不管我启动了多少子进程)？ 我是正确的还是我遗漏了会导致列表被复制的内容？

编辑: 在阅读了有关该主题的更多内容后，我仍然感到困惑。一方面，Linux 使用写时复制，这应该意味着没有数据被复制。另一方面，访问对象会改变它的引用计数(我仍然不确定为什么以及这意味着什么)。即便如此，是否会复制整个对象？

例如，如果我定义 someFunction 如下:

def someFunction(list1, list2, list3):
    i=random.randint(0,99999)
    print list1[i], list2[i], list3[i]

使用这个函数是否意味着l1、l2和l3将被完全复制到每个子进程？

有没有办法检查这个？

EDIT2 在阅读更多内容并在子进程运行时监控系统的总内存使用情况后，似乎确实为每个子进程复制了整个对象。这似乎是因为引用计数。

在我的程序中实际上不需要 l1、l2 和 l3 的引用计数。这是因为 l1、l2 和 l3 将保留在内存中(不变)，直到父进程退出。在此之前不需要释放这些列表使用的内存。事实上，我确信引用计数将保持在 0 以上(对于这些列表和这些列表中的每个对象)，直到程序退出。

所以现在问题变成了，我怎样才能确保对象不会被复制到每个子流程？我可以禁用这些列表和这些列表中的每个对象的引用计数吗？

EDIT3 只是一个附加说明。子流程不需要修改 l1、l2 和 l3 或这些列表中的任何对象。子进程只需要能够引用其中一些对象，而不需要为每个子进程复制内存。

Answer 1

因为这在 google 上仍然是一个非常高的结果，而且还没有其他人提到它，所以我想我会提到在 python 版本 3.8.0 中引入的“真正”共享内存的新可能性:https://docs.python.org/3/library/multiprocessing.shared_memory.html

我在这里包含了一个小例子(在 linux 上测试)，其中使用了 numpy 数组，这可能是一个非常常见的用例:

# one dimension of the 2d array which is shared
dim = 5000

import numpy as np
from multiprocessing import shared_memory, Process, Lock
from multiprocessing import cpu_count, current_process
import time

lock = Lock()

def add_one(shr_name):

    existing_shm = shared_memory.SharedMemory(name=shr_name)
    np_array = np.ndarray((dim, dim,), dtype=np.int64, buffer=existing_shm.buf)
    lock.acquire()
    np_array[:] = np_array[0] + 1
    lock.release()
    time.sleep(10) # pause, to see the memory usage in top
    print('added one')
    existing_shm.close()

def create_shared_block():

    a = np.ones(shape=(dim, dim), dtype=np.int64)  # Start with an existing NumPy array

    shm = shared_memory.SharedMemory(create=True, size=a.nbytes)
    # # Now create a NumPy array backed by shared memory
    np_array = np.ndarray(a.shape, dtype=np.int64, buffer=shm.buf)
    np_array[:] = a[:]  # Copy the original data into shared memory
    return shm, np_array

if current_process().name == "MainProcess":
    print("creating shared block")
    shr, np_array = create_shared_block()

    processes = []
    for i in range(cpu_count()):
        _process = Process(target=add_one, args=(shr.name,))
        processes.append(_process)
        _process.start()

    for _process in processes:
        _process.join()

    print("Final array")
    print(np_array[:10])
    print(np_array[10:])

    shr.close()
    shr.unlink()

请注意，由于 64 位整数，此代码可能需要大约 1gb 的 ram 才能运行，因此请确保您不会使用它来卡住您的系统。 ^_^