(这个问题是关于如何让 multiprocessing.Pool() 运行代码更快。我终于解决了，最终解决方案可以在帖子底部找到。)

原问题:

我正在尝试使用 Python 将一个单词与列表中的许多其他单词进行比较，并检索最相似的列表。为此，我使用了 difflib.get_close_matches 函数。我在使用 Python 2.6.5 的相对较新且功能强大的 Windows 7 笔记本电脑上。

我想要的是加快比较过程，因为我的单词比较列表很长，我必须多次重复比较过程。当我听说多处理模块时，如果比较可以分解为工作任务并同时运行(从而利用机器功率来换取更快的速度)，我的比较任务将更快地完成，这似乎是合乎逻辑的。

然而，即使尝试了许多不同的方法，并使用了文档中显示和论坛帖子中建议的方法，Pool 方法似乎非常慢，比仅在整个列表上运行原始 get_close_matches 函数慢得多一次。我想帮助理解为什么 Pool() 如此缓慢以及我是否正确使用它。我只使用这个字符串比较场景作为例子，因为这是我能想到的最近的例子，我无法理解或让多处理工作而不是反对我。下面只是来自 difflib 场景的示例代码，显示了普通方法和 Pooled 方法之间的时间差异:

from multiprocessing import Pool
import random, time, difflib

# constants
wordlist = ["".join([random.choice([letter for letter in "abcdefghijklmnopqersty"]) for lengthofword in xrange(5)]) for nrofwords in xrange(1000000)]
mainword = "hello"

# comparison function
def findclosematch(subwordlist):
    matches = difflib.get_close_matches(mainword,subwordlist,len(subwordlist),0.7)
    if matches <> []:
        return matches

# pool
print "pool method"
if __name__ == '__main__':
    pool = Pool(processes=3)
    t=time.time()
    result = pool.map_async(findclosematch, wordlist, chunksize=100)
    #do something with result
    for r in result.get():
        pass
    print time.time()-t

# normal
print "normal method"
t=time.time()
# run function
result = findclosematch(wordlist)
# do something with results
for r in result:
    pass
print time.time()-t

>>> 
pool method
37.1690001488 seconds
normal method
10.5329999924 seconds
>>> 

from multiprocessing import Process, Queue
import difflib, random, time

def f2(wordlist, mainwordlist, q):
    for mainword in mainwordlist:
        matches = difflib.get_close_matches(mainword,wordlist,len(wordlist),0.7)
        q.put(matches)

if __name__ == '__main__':

    # constants (for 50 input words, find closest match in list of 100 000 comparison words)
    q = Queue()
    wordlist = ["".join([random.choice([letter for letter in "abcdefghijklmnopqersty"]) for lengthofword in xrange(5)]) for nrofwords in xrange(100000)]
    mainword = "hello"
    mainwordlist = [mainword for each in xrange(50)]

    # normal approach
    t = time.time()
    for mainword in mainwordlist:
        matches = difflib.get_close_matches(mainword,wordlist,len(wordlist),0.7)
        q.put(matches)
    print time.time()-t

    # split work into 5 or 10 processes
    processes = 5
    def splitlist(inlist, chunksize):
        return [inlist[x:x+chunksize] for x in xrange(0, len(inlist), chunksize)]
    print len(mainwordlist)/processes
    mainwordlistsplitted = splitlist(mainwordlist, len(mainwordlist)/processes)
    print "list ready"

    t = time.time()
    for submainwordlist in mainwordlistsplitted:
        print "sub"
        p = Process(target=f2, args=(wordlist,submainwordlist,q,))
        p.Daemon = True
        p.start()
    for submainwordlist in mainwordlistsplitted:
        p.join()
    print time.time()-t
    while True:
        print q.get()

最佳答案

我最好的猜测是进程间通信 (IPC) 开销。在单进程实例中，单进程有单词列表。当委托(delegate)给各种其他进程时，主进程需要不断地将列表的部分穿梭到其他进程。

因此，更好的方法可能是分拆 n 个进程，每个进程负责加载/生成列表的 1/n 段并检查单词是否在列表的该部分中。

不过，我不确定如何使用 Python 的多处理库来做到这一点。

关于python - multiprocessing.Pool() 比仅使用普通函数慢，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/20727375/