这里我将使用一个使用shared_memory的共享数组，因为如果没有两个循环迭代使用相同的内存地址，就不需要保护写访问。我删除了第二个数组以缩短示例（只构建一个共享数组），并且我重新排序了数组形状以更好地保留内存对齐访问。

from multiprocessing import Pool
from multiprocessing.shared_memory import SharedMemory
import numpy as np
import numpy.typing as npt
from typing import Any
from time import sleep

def dothing(arr: np.ndarray, t_func: Any) -> np.ndarray:
    sleep(.05) #simulate hard work
    return arr * 2

def dodothing(args: tuple[int, Any]):
    global arr
    index = args[0]
    t_func = args[1]
    arr[index] = dothing(arr[index], t_func) #write result back to self to avoid need for 2 shared arrays

def init(shm: SharedMemory, shape: tuple[int, ...], dtype: npt.DTypeLike):
    global arr
    arr = np.ndarray(shape, dtype=dtype, buffer=shm.buf)

if __name__ == "__main__":
    _A = np.ones((513,81,81), np.float64) #source data

    t_funcs = ["some transfer function"] * _A.shape[0] #added example of passing some data + an index

    nbytes = _A.size * _A.itemsize
    dtype = _A.dtype
    shape = _A.shape

    shm = SharedMemory(create=True, size=nbytes)

    A = np.ndarray(shape, dtype=dtype, buffer=shm.buf)

    A[:] = _A[:] #copy contents into shared A

    with Pool(initializer=init, initargs=(shm, shape, dtype)) as pool:
        pool.map(dodothing, enumerate(t_funcs)) #enumerate returns tuple[int,Any] each loop

    print(A.sum()/_A.sum()) #prove we multiplied all elements by 2

    shm.close()
    shm.unlink()

multiprocessing.Pool有时候在目标函数的有效参数方面有点滑稽，所以我倾向于通过池的初始化函数来共享Lock、Queue、shared_memory等内容，该函数像Process一样接受参数。