Question

在我的程序中，我需要在Python的多处理过程之间共享一个字典。我简化了代码，在这里举了一个例子：

import multiprocessing
def folding (return_dict, seq):
    dis = 1
    d = 0
    ddg = 1 
    '''This is irrelevant, actually my program sends seq parameter to other extern program that returns dis, d and ddg parameters'''
    return_dict [seq] = [dis, d, ddg]

seqs = ['atcgtg', 'agcgatcg', 'atcgatcgatc', atcggatcg', agctgctagct']
manager = Manager()
return_dict = manager.dict()
n_cores = 3

for i in range (0, len(seqs), n_cores) #n_cores is the number of cores availables in the computer, defined by the user
    subseqs = seqs[i:i + n_cores]
    processes = [Process(target=folding, args =(return_dict, seq)) for seq in subseqs]
    for p in processes:
        p.start()
    for p in processes:
        p.join()

for i in retun_dict:
    print i

我希望在程序结束时使用所有属性值的return_dict。当我运行我的程序时，必须用数千个序列的seqs列表执行此操作并重复很多次，有时我会得到正确的结果，但有时（大部分时间）程序永远不会结束，但会重新运行错误，我不知道出了什么问题。此外，我认为这在时间上效率不高，我想知道是否有其他方法可以更有效，更快地完成这项工作。谢谢大家！

Answer 1

通过修复一些小的语法错误，您的代码似乎可以正常工作。

但是，我会使用multiprocessing pool代替您的自定义解决方案，一次运行n_cores个进程。您的方法存在的问题是，在开始下一批之前，所有流程都需要完成。根据您需要计算folding的时间变量，您可能会遇到瓶颈。在最坏的情况下，与单核处理相比，这意味着没有任何加速。

此外，您的程序将在Windows下遇到严重问题。您需要确保可以安全地导入主模块，而无需重新运行多处理代码。也就是说，您需要通过if __name__ == '__main___'保护您的主入口点，这可能已经在其他python脚本中看到了。这将确保只有当您的脚本作为解释器中的 main 文件启动时才会执行受保护的代码，即只生成一次，而不是由您生成的每个新子进程启动。

以下是我使用池稍微更改的代码版本：

import multiprocessing as mp


def folding(return_dict, seq):
    dis = 1
    d = 0
    ddg = 1
    '''This is irrelevant, actually my program sends seq parameter to other extern program that returns dis, d and ddg parameters'''
    return_dict[seq] = [dis, d, ddg]


def main():
    seqs = ['atcgtg', 'agcgatcg', 'atcgatcgatc', 'atcggatcg', 'agctgctagct']
    manager = mp.Manager()
    return_dict = manager.dict()
    n_cores = 3

    # created pool running maximum 3 cores
    pool = mp.Pool(n_cores)

    # Execute the folding task in parallel
    for seq in seqs:
        pool.apply_async(folding, args=(return_dict, seq))

    # Tell the pool that there are no more tasks to come and join
    pool.close()
    pool.join()

    # Print the results
    for i in return_dict.keys():
        print(i, return_dict[i])


if __name__ == '__main__':
    # Protected main function
    main()

这将打印

atcgtg [1, 0, 1]
atcgatcgatc [1, 0, 1]
agcgatcg [1, 0, 1]
atcggatcg [1, 0, 1]
agctgctagct [1, 0, 1]

没有共享数据的示例

编辑：同样在您的情况下，实际上不需要共享数据结构。您可以简单地依赖pool's map函数。 map 采用 iterable ，然后用于调用函数folding，其中包含iterable的所有元素一次。在 map_asnyc 上使用 map 的优点是结果按输入顺序排列。但是你需要等到收集完所有结果，直到你可以处理它们为止。

以下是使用 map 的示例。请注意，您的函数folding现在返回结果，而不是将其放入共享字典中：

import multiprocessing as mp


def folding(seq):
    dis = 1
    d = 0
    ddg = 1
    '''This is irrelevant, actually my program sends seq parameter to other extern program that returns dis, d and ddg parameters'''
    # Return results instead of using shared data
    return [dis, d, ddg]


def main():
    seqs = ['atcgtg', 'agcgatcg', 'atcgatcgatc', 'atcggatcg', 'agctgctagct']
    n_cores = 3

    pool = mp.Pool(n_cores)

    # Use map which blocks until all results are ready:
    res = pool.map(folding, iterable=seqs)

    pool.close()
    pool.join()

    # Print the results
    # Using list(zip(..)) to print inputs next to outputs
    print(list(zip(seqs, res)))


if __name__ == '__main__':
    main()

这个打印

[('atcgtg', [1, 0, 1]), ('agcgatcg', [1, 0, 1]), ('atcgatcgatc', [1, 0, 1]), ('atcggatcg', [1, 0, 1]), ('agctgctagct', [1, 0, 1])]

使用python在多处理中共享字典

1 个答案:

没有共享数据的示例