转 Python 多进程multiprocessing.Process之satrt()和join()

1、

https://blog.csdn.net/wonengguwozai/article/details/80325745

今天项目中涉及到了使用多进程处理数据，在廖雪峰的python教程上学习了一下多进程相关，其中涉及到了start和join函数，解释的不是很清晰，在网上找了博客，敲了下博客提供的代码，瞬间理解了。感谢原文：https://blog.csdn.net/HeatDeath/article/details/72842899

由于Python是跨平台的，自然也应该提供一个跨平台的多进程支持。

multiprocessing模块就是跨平台版本的多进程模块。

multiprocessing模块提供了一个Process类来代表一个进程对象。

创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例

start()方法启动，这样创建进程比fork()还要简单。

join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步。（进一步地解释，哪个子进程调用了join方法，主进程就要等该子进程执行完后才能继续向下执行，具体可见下边的分析图）

使用 join()

# -*- coding:utf-8 -*-
from multiprocessing import Process
import os
import time
def run_proc(name):
time.sleep(10)
print('Run child process %s (%s)...' % (name, os.getpid()))
def hello_world():
# time.sleep(5)
time.sleep(20)
print('hello world!')
print('Run child process (%s)...' % (os.getpid()))
if __name__ == '__main__':
print ('Parent process %s.' % os.getpid())
p1 = Process(target=run_proc, args=('test',))
p2 = Process(target=hello_world)
print 'Process will start.'
p1.start()
p2.start()
p1.join()
print('Process end.')

输出：

Parent process 11860.
Process will start.
Run child process test (11232)...
Process end.
hello world!
Run child process (2288)...
Process finished with exit code 0

子进程的开始时间

# -*- coding:utf-8 -*-
from multiprocessing import Process
import os
import time
def run_proc(name):
print(time.time())
time.sleep(10)
print('Run child process %s (%s)...' % (name, os.getpid()))
def hello_world():
print(time.time())
# time.sleep(5)
time.sleep(20)
print('hello world!')
print('Run child process (%s)...' % (os.getpid()))
if __name__ == '__main__':
print ('Parent process %s.' % os.getpid())
p1 = Process(target=run_proc, args=('test',))
p2 = Process(target=hello_world)
print 'Process will start.'
p1.start()
p2.start()
p1.join()
print('Process end.')

输出：

Parent process 7220.
Process will start.
1496374096.56
1496374096.56
Run child process test (2196)...
Process end.
hello world!
Run child process (832)...
Process finished with exit code 0

可以认为子进程 p1 与子进程 p2 同时开始

去掉 join(),使用 map

# -*- coding:utf-8 -*-
from multiprocessing import Process
import os
import time
def run_proc(name):
print(time.time())
time.sleep(10)
print('Run child process %s (%s)...' % (name, os.getpid()))
def hello_world():
print(time.time())
# time.sleep(5)
time.sleep(20)
print('hello world!')
print('Run child process (%s)...' % (os.getpid()))
if __name__ == '__main__':
print ('Parent process %s.' % os.getpid())
p1 = Process(target=run_proc, args=('test',))
p2 = Process(target=hello_world)
print 'Process will start.'
# p1.start()
# p2.start()
# p1.join()
p_list = (p1, p2)
map(Process.start, p_list)
print('Process end.')

输出：

Parent process 8580.
Process will start.
Process end.
1496374397.24
1496374397.24
Run child process test (7148)...
hello world!
Run child process (8348)...
Process finished with exit code 0

https://blog.csdn.net/yagamil/article/details/51284851

threads=[]
f=[fast,slow]
l=len(f)
for i in range(l):
t=MyThread(f[i],(),str(i))
threads.append(t)

for i in range(l):
threads[i].start()

for i in range(l):
#pass
threads[i].join()
print threads[i].getName()
print "Done on main"
exit()

join的主要功能是阻塞线程，也就是使用了join后，后面的语句需要等当前进程完成之后才能执行。

那么看看下面的例子

class MyThread(threading.Thread):
def __init__(self,fun,arg,name=""):
threading.Thread.__init__(self)
self.fun=fun
self.arg=arg
self.name=name
#self.result

def run(self):
self.result=apply(self.fun,self.arg)

def getName(self):
return self.name

def getResult(self):
return self.result

上面是一个多线程的类。待会用来调用的。
下面是main函数

def fast():
print "in fast"
sleep(15)
print "done in fast"

def slow():
print "in slow"
sleep(10)
print "done in slow"

threads=[]
f=[fast,slow]
l=len(f)
for i in range(l):
t=MyThread(f[i],(),str(i))
threads.append(t)

for i in range(l):
threads[i].start()

for i in range(l):
#pass
threads[i].join()
print threads[i].getName()
print "Done on main"
exit()

运行之后
输出的结果是

in fast
in slow
done in slow
done in fast
0
1
Done on main

看到了吗？

运行到thread[i].join() 这一行，下一句没有马上被执行，需要等到done in fast 完成之后才执行，而为什么done in slow却提前被执行了呢？

因为上面执行了threads[i].start() 后两个线程已经同时开启了，但是由于在slow线程里只sleep了10秒，而fast线程sleep了15秒，所以会先打印done in slow。

print threads[i].getName()

而上面这句则需要等线程1执行之后才会执行，

等执行完了上面那句之后，才会执行线程2的 join(), 由于此时的线程已经早已执行完毕，所以这句也没有起到阻塞作用，故会马上执行下面只一句

print threads[i].getName()
---------------------
作者：重复的生活
来源：CSDN
原文：https://blog.csdn.net/yagamil/article/details/51284851
版权声明：本文为博主原创文章，转载请附上博文链接！