如何在 Python 多重处理中高效共享大型只读数据？

在多处理中维护共享只读数据

问题：

在 Python 多处理环境中，如何确保在不创建副本的情况下在多个进程之间共享相当大的只读数组（例如 3 Gb）？

答案：

利用由多处理模块与 NumPy 结合使用，可以在进程之间高效共享数据。

<code class="python">import multiprocessing
import ctypes
import numpy as np

shared_array_base = multiprocessing.Array(ctypes.c_double, 10*10)
shared_array = np.ctypeslib.as_array(shared_array_base.get_obj())
shared_array = shared_array.reshape(10, 10)</code>

这种方法利用了 Linux 对 fork() 采用写时复制语义的事实，确保仅在以下情况下才复制数据：修改的。因此，即使没有显式使用 multiprocessing.Array，数据也会在进程之间有效共享，除非发生更改。

<code class="python"># Parallel processing
def my_func(i, def_param=shared_array):
    shared_array[i,:] = i

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=4)
    pool.map(my_func, range(10))

    print(shared_array)</code>

此代码同时修改共享数组并演示了在多个进程之间成功共享数据：

[[ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]
 [ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]
 [ 2.  2.  2.  2.  2.  2.  2.  2.  2.  2.]
 [ 3.  3.  3.  3.  3.  3.  3.  3.  3.  3.]
 [ 4.  4.  4.  4.  4.  4.  4.  4.  4.  4.]
 [ 5.  5.  5.  5.  5.  5.  5.  5.  5.  5.]
 [ 6.  6.  6.  6.  6.  6.  6.  6.  6.  6.]
 [ 7.  7.  7.  7.  7.  7.  7.  7.  7.  7.]
 [ 8.  8.  8.  8.  8.  8.  8.  8.  8.  8.]
 [ 9.  9.  9.  9.  9.  9.  9.  9.  9.  9.]]

通过利用共享内存和写时复制语义，此方法提供了一种有效的解决方案，用于在多处理环境中的进程之间共享大量只读数据。

以上是如何在 Python 多重处理中高效共享大型只读数据？的详细内容。更多信息请关注PHP中文网其他相关文章！