Question

我在python中编写了我的第一个多处理程序。

我想创建一个要处理的值列表，8个进程（数字os 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

而且，我有以下问题：

程序永不停止
我离开了RAM

Answer 1

将您的代码简化为以下内容：

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)那样运行它，你会看到到底发生了什么，你的指数逐渐增长到你内存不足的程度，你不会陷入困境中卡在for循环中。

这是第12个过程的输出，在几分之一秒后添加print(len(srt(valor)))并且它一直在继续：

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

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

创建的最后一个号码是：

 6021340351084089657109340225536

使用你自己的代码，你似乎陷入了困境，但它是勇敢的在for循环中增长到数字的数字为：

然后......

Answer 2

问题不在于您的多处理代码。它是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)

它需要4 GB内存的3 * pow（2,65）次。

Python中的多处理以处理参数列表

2 个答案: