Python中的多进程处理列表参数

Question

Python中的多进程处理列表参数

3

我正在编写我的第一个Python多进程程序。

我想创建一个值列表以进行处理，8个进程（CPU核心数）将消耗和处理该值列表。

我编写了以下Python代码：

__author__ = 'Rui Martins'

from multiprocessing import cpu_count, Process, Lock, Value

def proc(lock, number_of_active_processes, valor):
    lock.acquire()
    number_of_active_processes.value+=1
    print "Active processes:", number_of_active_processes.value
    lock.release()
    # DO SOMETHING ...
    for i in range(1, 100):
        valor=valor**2
    # (...)
    lock.acquire()
    number_of_active_processes.value-=1
    lock.release()

if __name__ == '__main__':
    proc_number=cpu_count()
    number_of_active_processes=Value('i', 0)
    lock = Lock()
    values=[11, 24, 13, 40, 15, 26, 27, 8, 19, 10, 11, 12, 13]
    values_processed=0

    processes=[]
    for i in range(proc_number):
        processes+=[Process()]
    while values_processed<len(values):
        while number_of_active_processes.value < proc_number and values_processed<len(values):
            for i in range(proc_number):
                if not processes[i].is_alive() and values_processed<len(values):
                    processes[i] = Process(target=proc, args=(lock, number_of_active_processes, values[values_processed]))
                    values_processed+=1
                    processes[i].start()

            while number_of_active_processes.value == proc_number:
                # BUG: always number_of_active_processes.value == 8 :(
                print "Active processes:", number_of_active_processes.value

    print ""
    print "Active processes at END:", number_of_active_processes.value

我有以下问题：

程序永远不会停止
内存不足

- Rui Martins

Daniel Sanchez，我认为多进程与线程不同，并且使用多进程时GIL不会被锁定。参见：https://dev59.com/TXA75IYBdhLWcg3w6Ndj?rq=1 - Rui Martins

是的，我在发布那个愚蠢的帖子后就想到了这一点，很抱歉 :/ - Netwave

2个回答

0

问题不在于你的多进程代码，而是在for循环中的pow运算符：

for i in range(1, 100):
        valor=valor**2

最终结果将是pow（val，2 ** 100），这太大了，计算它将耗费太多时间和内存。因此，您最后会遇到内存错误。

4 GB = 4 * pow(2, 10) * pow(2, 10) * pow(2, 20) * 8 bit = 2**35 bit

而对于您的最小数8：

pow(8, 2**100) = pow(2**3, 2**100) = pow(2, 3*pow(2, 100))
pow(2, 3*pow(2, 100))bit/4GB = 3*pow(2, 100-35) = 3*pow(2, 65)

它需要3*pow(2, 65)次4 GB内存。

- oxnz

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Padraic Cunningham · Accepted Answer

简化您的代码如下：

def proc(lock, number_of_active_processes, valor):
    lock.acquire()
    number_of_active_processes.value += 1
    print("Active processes:", number_of_active_processes.value)
    lock.release()
    # DO SOMETHING ...
    for i in range(1, 100):
        print(valor)
        valor = valor **2
    # (...)
    lock.acquire()
    number_of_active_processes.value -= 1
    lock.release()


if __name__ == '__main__':
    proc_number = cpu_count()
    number_of_active_processes = Value('i', 0)

    lock = Lock()
    values = [11, 24, 13, 40, 15, 26, 27, 8, 19, 10, 11, 12, 13]
    values_processed = 0

    processes = [Process() for _ in range(proc_number)]
    while values_processed < len(values)-1:
        for p in processes:
            if not p.is_alive():
                p = Process(target=proc,
                            args=(lock, number_of_active_processes, values[values_processed]))
                values_processed += 1
                p.start()

如果按照以上方式运行，添加print(valor)后，您将看到正在发生的事情，即指数增长valor直到内存耗尽，您不会卡在while循环中，而是卡在for循环中。这是在第12个进程中添加print(len(srt(valor)))后的输出，在几分之一秒后它仍在继续。

将以下内容翻译成中文：

只需将您的循环更改为以下内容：

for i in range(1, 100):
    print(valor)
    valor = valor *2

最后创建的数字是：

 6021340351084089657109340225536

使用您自己的代码，似乎会在 while 循环中卡住，但是其值在 for 循环中增长到与以下数字一样多的位数：

而且......