多进程模块问题：如何实现多哈希进程+单求和进程的并行处理

我来帮你搞定这个多进程并行处理哈希的问题！先看看你现有代码里的小问题：你现在每个哈希进程都拿到了完整的words列表，这会导致所有进程重复处理相同的单词，完全没起到并行的作用。接下来我给你两种解决方案，一种是基于你现有Process+Queue的改造，另一种是更简洁的Pool实现方案，你可以根据需求选择。

方案一：改造现有Process+Queue代码 #

这个方案会保留你原有的队列和锁机制，主要修改任务拆分和END信号的处理逻辑：

修改后的完整代码 #

import multiprocessing as mp
from time import sleep
from random import random

def hasher(q, l, sub_words):
    # 每个进程只处理分配给自己的子单词列表
    for word in sub_words:
        l.acquire()
        h = hash(word)
        print(f'hash of {word} is {h}')
        l.release()
        sleep(1.0 * random())
        q.put(h)
    # 每个哈希进程处理完自己的任务后发送END信号
    q.put('END')

def summer(q, l, total_hash_processes):
    end_count = 0
    while True:
        data = q.get()
        sleep(0.1 * random())
        if data == 'END':
            end_count += 1
            # 收到所有哈希进程的END信号后退出
            if end_count == total_hash_processes:
                break
        else:
            l.acquire()
            digit_sum = sum(int(x) for x in str(abs(data)))
            print(f'sum of {data} is {digit_sum}')
            l.release()

if __name__ == '__main__':
    queue = mp.Queue()
    lock = mp.Lock()
    words = ['fwiimaafqa', 'nuwivfmgdc', 'foymwgcbut', 'sefmayofio', 'crbgzpihpa', 
             'xsioddsfyw', 'zbefmckkyi', 'vkxymewyvt', 'ryrvrfkjqf', 'zobdvstxfh']
    
    # 设置哈希进程的数量
    hash_process_num = 3
    bots = []
    
    # 拆分单词列表，分给每个哈希进程
    chunk_size = len(words) // hash_process_num
    for i in range(hash_process_num):
        # 处理最后一个进程可能多出来的单词
        if i == hash_process_num - 1:
            sub_words = words[i*chunk_size:]
        else:
            sub_words = words[i*chunk_size : (i+1)*chunk_size]
        # 创建并启动哈希进程
        bot = mp.Process(target=hasher, args=(queue, lock, sub_words))
        bot.start()
        bots.append(bot)
    
    # 启动求和进程，传入哈希进程总数
    bot2 = mp.Process(target=summer, args=(queue, lock, hash_process_num))
    bot2.start()
    
    # 等待所有哈希进程结束
    for bot in bots:
        bot.join()
    # 等待求和进程结束
    bot2.join()

关键改动说明 #

• 任务拆分：把words列表拆分成多个子列表，每个哈希进程只处理自己的子列表，避免重复计算。
• END信号计数：求和进程需要知道总共有多少个哈希进程，只有收到对应数量的END信号后才会退出，确保所有哈希结果都被处理。
• 锁的正确使用：保持锁来同步打印操作，避免输出混乱。

方案二：用Pool实现更简洁的并行处理 #

如果你不需要实时把哈希结果传给求和进程，而是等所有哈希计算完成后再统一处理，用multiprocessing.Pool会更简洁，它会自动帮你管理进程和收集结果：

完整代码 #

import multiprocessing as mp
from time import sleep
from random import random

def hash_single(word):
    # 单个单词的哈希计算，模拟耗时
    sleep(1.0 * random())
    h = hash(word)
    print(f'hash of {word} is {h}')
    return h

def summer(hash_results):
    # 批量处理哈希值的求和
    for h in hash_results:
        sleep(0.1 * random())
        digit_sum = sum(int(x) for x in str(abs(h)))
        print(f'sum of {h} is {digit_sum}')

if __name__ == '__main__':
    words = ['fwiimaafqa', 'nuwivfmgdc', 'foymwgcbut', 'sefmayofio', 'crbgzpihpa', 
             'xsioddsfyw', 'zbefmckkyi', 'vkxymewyvt', 'ryrvrfkjqf', 'zobdvstxfh']
    
    # 创建进程池，设置并行进程数
    with mp.Pool(processes=3) as pool:
        # 并行处理所有单词的哈希计算，收集结果
        hash_results = pool.map(hash_single, words)
    
    # 单进程处理求和
    summer(hash_results)

为什么这个方案更简洁？ #

• Pool.map会自动把任务分配给多个进程，完成后统一返回结果列表，不需要手动管理队列和信号。
• 代码结构更清晰，适合这种批量处理、不需要实时交互的场景。
• 自动处理进程的创建和销毁，减少手动管理的复杂度。

你可以根据自己的实际需求选择方案：如果需要哈希计算完成一个就处理一个求和，选方案一；如果可以等所有哈希计算完再统一求和，方案二更省心。

内容的提问来源于stack exchange，提问作者Ma0