Python 多进程-进程拥有我的计算机

我只是想尝试一下如何使用multiprocessing.Lock（）

从以下示例着手：

这个例子实际上是：

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上，大量python.exe在cmd中运行。同时始终从进程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 

Edit认为这可能与名称空间有关，因此我尝试：

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 

---

你的脚本不会接管我的Ubuntu电脑，但会接管Windows电脑。解释如下：

多处理

要求子进程能够。在*NIX上发生的事情是，子进程是通过

os.fork

创建的，这意味着它们基本上是从父进程克隆的，并且已经导入了

\uuuuuu main\uuuuu

。再次进口也没有坏处

在Windows上，没有，因此孩子们实际上需要再次导入main。但是，当他们导入main时，脚本中的所有代码都会被执行，从而导致子脚本释放更多的子脚本。当你使用

if __name__ == "__main__":

子句，可以防止子对象的无限循环生成子对象

---

这实际上是在多处理规范中。

如果块则需要将进程运行代码包装在

中。发生的事情是，每个子流程都在导入并重新运行流程创建循环，创建一个无限的流程创建循环（正如您所看到的，这样会杀死您的计算机）。如果将进程启动循环包装在
中，则会导致进程启动代码仅在主进程中运行，而不是在所有子进程中运行。
什么操作系统<代码>多处理
在*NIX和Windows上的工作方式不同。在导入语句完成后的右侧XP框上，
打印“导入完成！”。我的猜测是，每个新进程都会导入自己的模块副本。然后它会重复出现，因为它不受
的保护，如果uuuu name\uuuuu='\uuuu main\uuuuu'：
。这是演示正在发生的事情的一个很好的方法+1当你发布链接时，Hanks刚刚在文档中看到了便笺，谢谢你的回答！子模块导入主模块，但可能不是作为
\uuuuuu main\uuuuu
导入，否则如果uuuu name\uuuuu==“\uuuuuuu main\uuuuu”
将无法工作，则保护
。为了避免fork bomb，在最新版本的Windows上引发了运行时错误。