Question

我只是想了解如何使用multiprocessing.Lock（）

使用以下示例：

http://docs.python.org/2/library/multiprocessing.html

这个例子实际上是：

from multiprocessing import Process, Lock

def f(l, i):
    l.acquire()
    print 'hello world', i
    l.release()

if __name__ == '__main__':
    lock = Lock()

    for num in range(10):
        Process(target=f, args=(lock, num)).start()

我将此作为我的代码：

from multiprocessing import Process, Lock
import datetime
import time
import random


def function(lock, i):
        now = datetime.datetime.now()
        time.sleep(random.randint(0,3))
        lock.acquire()
        print "%s says hello, World! at time: %s"  % (i,now)
        lock.release()



lock = Lock()
for i in range(2):
        Process(target=function,args=(lock,i)).start()

在shell中运行它会导致计算机锁定100％cpu，并在cmd中运行数十个python.exe。虽然始终从进程0或一个进程打印消息。看看这个例子，我意识到我错过了：

if __name__ == '__main__':

所以我加上它担心货物编码上帝，并且孤独地看到：

from multiprocessing import Process, Lock
import datetime
import time
import random


def function(lock, i):
    now = datetime.datetime.now()
    time.sleep(random.randint(0,3))
    lock.acquire()
    print "%s says hello, World! at time: %s"  % (i,now)
    lock.release()


if __name__ == "__main__":
    lock = Lock()
    for i in range(2):
        Process(target=function,args=(lock,i)).start()

打印：

1 says hello, World! at time: 2013-05-20 19:40:13.843000 
0 says hello, World! at time: 2013-05-20 19:40:13.843000

编辑认为它可能与命名空间有关，所以我尝试了：

from multiprocessing import Process, Lock
import datetime
import time
import random


def function(l, i):
    now = datetime.datetime.now()
    time.sleep(random.randint(0,3))
    l.acquire()
    print "%s says hello, World! at time: %s"  % (i,now), i
    l.release()



lock = Lock()
for i in range(2):
    Process(target=function,args=(lock,i)).start()

仍然是同一个问题

让我迷茫的颜色？！任何人都可以对此作出解释吗？

最终编辑：

这就是我现在完成我的小示例代码的方法：

from multiprocessing import Process, Lock
import datetime
import time
import random
print "imports done"

def function(l, i):
    now = datetime.datetime.now()
    time.sleep(random.randint(0,3))
    l.acquire()
    print "%s says hello, World! at time: %s"  % (i,now)
    l.release()


def main():
    lock = Lock()
    for i in range(2):
        Process(target=function,args=(lock,i)).start()

if __name__ == "__main__":
    main()

打印哪些：

imports done
imports done
imports done
1 says hello, World! at time: 2013-05-20 23:26:41.015000 
0 says hello, World! at time: 2013-05-20 23:26:41.015000

Answer 1

您的脚本不接管我的Ubuntu计算机，但它将接管Windows计算机。这是解释：

multiprocessing要求子进程能够import __main__。在* NIX上发生的事情是子进程是通过os.fork创建的，这意味着它们基本上是从已导入__main__的父进程克隆的。再次导入它并没有坏处。

在Windows上，没有os.fork，因此孩子实际上需要再次import __main__。但是，当他们import __main__时，该脚本中的所有代码都会被执行，这会导致孩子们产生更多的孩子。当你使用

if __name__ == "__main__":

子句，可以防止孩子产生孩子的无限循环。

这在多处理规范中实际上是documented to an extent。

Answer 2

您需要将流程运行代码包装在if __name__ == '__main__'块中。发生的事情是每个子进程都导入并重新运行您的进程创建循环，创建一个无限的进程创建循环（从而杀死您的计算机，如您所见）。将进程启动循环包装在if __name__ == '__main__'中将导致进程启动代码仅在主进程中运行，而不是在所有子进程中运行。

多处理 - 进程拥有我的计算机

2 个答案: