7

我想对从文件加载的一些输入数据运行并行计算。（文件可能非常大，所以我为此使用了一个生成器。）

在一定数量的项目上，我的代码运行正常，但高于此阈值程序挂起（一些工作进程没有结束）。

有什么建议么？（我用 python2.7 运行这个，8 个 CPU；5000 行仍然可以，7500 行不行。）

首先，您需要一个输入文件。在 bash 中生成它： 

for i in {0..10000}; do echo -e "$i"'\r' >> counter.txt; done

然后，运行这个： 

python2.7 main.py 100 counter.txt > run_log.txt

主要.py： 

#!/usr/bin/python2.7
import os, sys, signal, time
import Queue
import multiprocessing as mp

def eat_queue(job_queue, result_queue):
    """Eats input queue, feeds output queue
    """
    proc_name = mp.current_process().name
    while True:
        try:
            job = job_queue.get(block=False)
            if job == None:
                print(proc_name + " DONE")
                return
            result_queue.put(execute(job))
        except Queue.Empty:
            pass    

def execute(x):
    """Does the computation on the input data
    """
    return x*x

def save_result(result):
    """Saves results in a list
    """
    result_list.append(result)

def load(ifilename):
    """Generator reading the input file and
        yielding it row by row
    """
    ifile = open(ifilename, "r")
    for line in ifile:
        line = line.strip()
        num = int(line)
        yield (num)
    ifile.close()
    print("file closed".upper())

def put_tasks(job_queue, ifilename):
    """Feeds the job queue
    """
    for item in load(ifilename):
        job_queue.put(item)
    for _ in range(get_max_workers()):
        job_queue.put(None)

def get_max_workers():
    """Returns optimal number of processes to run
    """
    max_workers = mp.cpu_count() - 2
    if max_workers < 1:
        return 1
    return max_workers

def run(workers_num, ifilename):
    job_queue = mp.Queue()
    result_queue = mp.Queue()

    # decide how many processes are to be created
    max_workers = get_max_workers()
    print "processes available: %d" % max_workers
    if workers_num < 1 or workers_num > max_workers:
        workers_num = max_workers

    workers_list = []
    # a process for feeding job queue with the input file
    task_gen = mp.Process(target=put_tasks, name="task_gen",
                          args=(job_queue, ifilename))
    workers_list.append(task_gen)

    for i in range(workers_num):
        tmp = mp.Process(target=eat_queue, name="w%d" % (i+1),
                                      args=(job_queue, result_queue))
        workers_list.append(tmp)

    for worker in workers_list:
        worker.start()

    for worker in workers_list:
        worker.join()
        print "worker %s finished!" % worker.name

if __name__ == '__main__':
    result_list = []
    args = sys.argv
    workers_num = int(args[1])
    ifilename = args[2]
    run(workers_num, ifilename)
4

1 回答 1

8

这是因为您的代码中没有任何内容可以取消 result_queue任何内容。然后行为取决于内部队列缓冲细节：如果“不是很多”数据正在等待，一切看起来都很好，但如果“很多”数据正在等待，一切都会冻结。不能多说，因为它涉及到内部魔法层；-) 但是文档确实警告过它：

警告

如上所述，如果子进程已将项目放入队列（并且它没有使用 JoinableQueue.cancel_join_thread），则该进程将不会终止，直到所有缓冲项目都已刷新到管道。

这意味着如果您尝试加入该进程，您可能会遇到死锁，除非您确定已放入队列的所有项目都已被消耗。同样，如果子进程是非守护进程，则父进程在尝试加入其所有非守护子进程时可能会挂起退出。

请注意，使用管理器创建的队列不存在此问题。请参阅编程指南。

一种简单的修复方法：首先添加

            result_queue.put(None)

在eat_queue()返回之前。然后加：

count = 0
while count < workers_num:
    if result_queue.get() is None:
        count += 1

在主程序.join()的工人之前。这会耗尽结果队列，然后一切都会干净地关闭。

顺便说一句，这段代码很奇怪：

while True:
    try:
        job = job_queue.get(block=False)
        if job == None:
            print(proc_name + " DONE")
            return
        result_queue.put(execute(job))
    except Queue.Empty:
        pass

你为什么要做非阻塞get()？只要队列为空，这就会变成一个占用 CPU 的“忙循环”。的主要目的.get()是提供一种有效的方式来等待工作出现。所以：

while True:
    job = job_queue.get()
    if job is None:
        print(proc_name + " DONE")
        break
    else:
        result_queue.put(execute(job))
result_queue.put(None)

做同样的事情，但效率更高。

队列大小注意事项

你没有问这个问题，但让我们在它咬你之前把它盖住；-) 默认情况下， aQueue的大小没有限制。例如，如果您向 中添加 10 亿个项目Queue，它将需要足够的 RAM 来容纳 10 亿个项目。因此，如果您的生产者生成工作项的速度比您的消费者处理它们的速度要快，那么内存使用就会很快失控。

幸运的是，这很容易修复：指定最大队列大小。例如，

    job_queue = mp.Queue(maxsize=10*workers_num)
                         ^^^^^^^^^^^^^^^^^^^^^^^

然后job_queue.put(some_work_item)将阻塞，直到消费者将队列的大小减小到小于最大值。通过这种方式，您可以处理需要少量 RAM 的队列的巨大问题。

于 2013-12-13T20:19:09.807 回答