Python 如何在while循环中正确使用多处理apply_异步池

我需要使用一个池来异步解析来自提取方法的结果，并将这些结果发送到写入队列

我尝试过这个：但它似乎只是迭代运行。。。一个接一个的过程

process_pool = Pool(processes=30, maxtasksperchild=1)
while True:
    filepath = read_queue.get(True)
    if filepath is None:
        break
    res = process_pool.apply_async(func=process.run, args=(filepath, final_path), callback=write_queue.put)
    results.append(res)
    for result in results:
        result.wait()
process_pool.close()
process_pool.join()

我也尝试过只等待每个结果，但这与上面的操作相同：

process_pool = Pool(processes=30, maxtasksperchild=1)
while True:
    filepath = read_queue.get(True)
    if filepath is None:
        break
    res = process_pool.apply_async(func=process.run, args=(filepath, final_path), callback=write_queue.put)
    res.wait()
process_pool.close()
process_pool.join()

我还尝试了调度进程，并在没有工作人员生成时让池自身阻塞：

process_pool = Pool(processes=30, maxtasksperchild=1)
while True:
    filepath = read_queue.get(True)
    if filepath is None:
        break
    process_pool.apply_async(func=process.run, args=(filepath, final_path), callback=write_queue.put)
process_pool.close()
process_pool.join()

这不起作用，只是一次又一次地运行过程，实际上没有运行任何类型的函数，我不知道为什么。似乎我必须对

AsyncResult

做些什么，才能让池实际调度进程

我需要它像这样工作：

• 当队列中有结果等待时，使用队列中的特定参数在池中生成一个新进程
• 在回调时，将已处理的结果放入写入队列

然而，我似乎无法让它正确地异步工作。它只能以迭代的方式工作，因为我必须对结果做一些事情，以使任务能够正确地安排。无论是

.get

，

。wait

，随便什么

#write.py
def写入（p_列表）：
outfile=Path（'outfile.txt.bz2'）
对于p_列表中的数据：
如果路径存在（输出文件）：
模式='ab'
其他：
模式='wb'
将bz2.open（filename=outfile，mode=mode，compresslevel=9）作为输出：
temp=（str（数据）+'\n'）。编码（'utf-8'）
输出写入（临时）
打印（'JSON文件已写入'，flush=True）
类写入（进程）：
def uuu init uuu（self，write_队列：队列）：
进程。初始化（自）
self.write\u queue=写入队列
def运行（自）：
尽管如此：
尝试：
p_list=self.write_queue.get（True，900）
除空外：
持续
如果p_列表为无：
打破
写入（p_列表）
-
#process.py
def解析（数据：int）：
全局json_列表
time.sleep（.1）#模拟解析json
json_list.append（数据）
def读取（数据：int）：
时间。睡眠（.1）
解析（数据）
def运行（数据：int）：
全局json_列表
json_列表=[]
读取（数据）
返回json_列表
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
全局输出路径，json列表
-
#main.py
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
读取队列=队列（）
写入队列=队列（）
写入=写入（写入队列=写入队列）
write.daemon=True
write.start（）
对于范围（0，1000000）内的i：
read_queue.put（i）
read_queue.put（无）
进程池=池（进程=30，maxtasksperchild=1）
尽管如此：
数据=读取队列.get（真）
如果数据为无：
打破
res=process\u pool.apply\u async（func=process.run，args=（data，），callback=write\u queue.put）
写入队列。放置（无）
进程\u pool.close（）
进程\u pool.join（）
write.join（）
打印（'处理完成'）

所以，问题是没有问题。我只是愚蠢。如果您将每个工作人员的最大任务数定义为1，那么进程将非常快地调度，看起来什么都没有发生（或者可能只有我这么认为）

下面是一种合理的方法，可以在

while

循环中正确使用异步进程池，该循环使用

maxstasksparchild

的

1

如果uuuu name_uuuu=='\uuuuuuu main\uuuuuu':
def func（要素）：
睡眠时间（0.5）
返回元素
def回调（elem）：
#对处理过的数据做些什么
通过
队列=多处理。队列（）
对于范围（0，10000）内的i：
排队.付诸表决（i）
process\u pool=multiprocessing.pool（processs=num\u processes，maxstasksperchild=1）
结果=[]
尽管如此：
data=queue.get（True）
如果数据为无：
打破
res=process\u pool.apply\u async（func=func，args=（data，），callback=callback）
结果追加（res）
flag=False
对于i，枚举中的res（结果）：
尝试：
res.wait（600）
#做些日志记录
结果[i]=无
除时间错误外：
flag=True
#做些日志记录
进程\u pool.close（）
如果标志：
进程\u池。终止（）
进程\u pool.join（）
#完成了！

所以，问题是没有问题。我只是愚蠢。如果您将每个工作人员的最大任务数定义为1，那么进程将非常快地调度，看起来什么都没有发生（或者可能只有我这么认为）

下面是一种合理的方法，可以在

while

循环中正确使用异步进程池，该循环使用

maxstasksparchild

的

1

如果uuuu name_uuuu=='\uuuuuuu main\uuuuuu':
def func（要素）：
睡眠时间（0.5）
返回元素
def回调（elem）：
#对处理过的数据做些什么
通过
队列=多处理。队列（）
对于范围（0，10000）内的i：
排队.付诸表决（i）
process\u pool=multiprocessing.pool（processs=num\u processes，maxstasksperchild=1）
结果=[]
尽管如此：
data=queue.get（True）
如果数据为无：
打破
res=process\u pool.apply\u async（func=func，args=（data，），callback=callback）
结果追加（res）
flag=False
对于i，枚举中的res（结果）：
尝试：
res.wait（600）
#做些日志记录
结果[i]=无
除时间错误外：
flag=True
#做些日志记录
进程\u pool.close（）
如果标志：
进程\u池。终止（）
进程\u pool.join（）
#完成了！

您的第三个示例应该是有效的。事实上，

process.run

似乎从未执行过，这是非常奇怪的。你能做一个完整的复制机来显示问题吗？第一个示例是按顺序运行的，因为您将for循环放在

的内部，而True:

循环。移动for循环