2

我只是在尝试如何使用 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 或 1 的消息。看着这个例子，我意识到我错过了：

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
4

2 回答 2

8

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

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

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

if __name__ == "__main__":

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

这实际上在一定程度上记录在多处理规范中。

于 2013-05-20T18:51:08.493 回答
2

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

于 2013-05-20T18:51:35.880 回答