python多进程编程中常常能用到的几种方法

python中的多线程其实并不是真正的多线程，如果想要充分地使用多核cpu资源，在python中大部分情况需要使用多进程。python提供了非常好用的多进程包multiprocessing，只需要定义一个函数，python会完成其它所有事情。借助这个包，可以轻松完成从单进程到并发执行的转换。multiprocessing支持子进程、通信和共享数据、执行不同形式的同步，提供了process、queue、pipe、lock等组件

一、process

语法：process([group[,target[,name[,args[,kwargs]]]]])

参数含义：target表示调用对象；args表示调用对象的位置参数元祖；kwargs表示调用对象的字典。name为别名，groups实际上不会调用。

方法：is_alive()：

　　　join(timeout)：

　　　run()：

　　　start()：

　　　terminate()：

属性：authkey、daemon(要通过start()设置)、exitcode(进程在运行时为none、如果为-n，表示被信号n结束)、name、pid。其中daemon是父进程终止后自动终止，且自己不能产生新的进程，必须在start()之前设置。

1.创建函数，并将其作为单个进程

from multiprocessing import process
def func(name):
    print("%s曾经是好人"%name)

if __name__ == "__main__":
    p = process(target=func,args=('kebi',))
    p.start()   #start()通知系统开启这个进程

2.创建函数并将其作为多个进程

from multiprocessing import process
import random,time

def hobby_motion(name):
    print('%s喜欢运动'% name)
    time.sleep(random.randint(1,3))

def hobby_game(name):
    print('%s喜欢游戏'% name)
    time.sleep(random.randint(1,3))

if __name__ == "__main__":
    p1 = process(target=hobby_motion,args=('付婷婷',))
    p2 = process(target=hobby_game,args=('科比',))
    p1.start()
    p2.start()

执行结果：

付婷婷喜欢运动
科比喜欢游戏

3.将进程定义为类（开启进程的另一种方法，并不是很常用）

from multiprocessing import process
class myprocess(process):
    def __init__(self,name):
        super().__init__()
        self.name = name

    def run(self):  #start()时，run自动调用，而且此处只能定义为run。
        print("%s曾经是好人"%self.name)

if __name__ == "__main__":
    p = myprocess('kebi')
    p.start()  #将process当作父类，并且自定义一个函数。

4.daemon程序对比效果

不加daemon属性

import time
def func(name):
    print("work start:%s"% time.ctime())
    time.sleep(2)
    print("work end:%s"% time.ctime())

if __name__ == "__main__":
    p = process(target=func,args=('kebi',))
    p.start()
    print("this is over")

#执行结果
this is over
work start:thu nov 30 16:12:00 2017
work end:thu nov 30 16:12:02 2017

加上daemon属性

from multiprocessing import process
import time
def func(name):
    print("work start:%s"% time.ctime())
    time.sleep(2)
    print("work end:%s"% time.ctime())

if __name__ == "__main__":
    p = process(target=func,args=('kebi',))
    p.daemon = true   #父进程终止后自动终止，不能产生新进程，必须在start()之前设置
    p.start()
    print("this is over")

#执行结果
this is over

设置了daemon属性又想执行完的方法：

import time
def func(name):
    print("work start:%s"% time.ctime())
    time.sleep(2)
    print("work end:%s"% time.ctime())

if __name__ == "__main__":
    p = process(target=func,args=('kebi',))
    p.daemon = true
    p.start()
    p.join()  #执行完前面的代码再执行后面的
    print("this is over")

#执行结果
work start:thu nov 30 16:18:39 2017
work end:thu nov 30 16:18:41 2017
this is over

5.join()：上面的代码执行完毕之后，才会执行后i面的代码。

先看一个例子：

from multiprocessing import process
import time,os,random
def func(name,hour):
    print("a lifelong friend:%s,%s"% (name,os.getpid()))
    time.sleep(hour)
    print("good bother:%s"%name)

if __name__ == "__main__":
    p = process(target=func,args=('kebi',2))
    p1 = process(target=func,args=('maoxian',1))
    p2 = process(target=func,args=('xiaoniao',3))
    p.start()
    p1.start()
    p2.start()
    print("this is over")

执行结果：

this is over   #最后执行，最先打印，说明start()只是开启进程，并不是说一定要执行完
a lifelong friend:kebi,12048
a lifelong friend:maoxian,8252
a lifelong friend:xiaoniao,6068
good bother:maoxian   #最先打印，第二位执行
good bother:kebi     
good bother:xiaoniao

添加join（）

from multiprocessing import process
import time,os,random
def func(name,hour):
    print("a lifelong friend:%s,%s"% (name,os.getpid()))
    time.sleep(hour)
    print("good bother:%s"%name)
start = time.time()
if __name__ == "__main__":
    p = process(target=func,args=('kebi',2))
    p1 = process(target=func,args=('maoxian',1))
    p2 = process(target=func,args=('xiaoniao',3))
    p.start()
    p.join()   #上面的代码执行完毕之后，再执行后面的
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    print("this is over")
    print(time.time() - start)

#执行结果
a lifelong friend:kebi,14804
good bother:kebi
a lifelong friend:maoxian,11120
good bother:maoxian
a lifelong friend:xiaoniao,10252  #每个进程执行完了，才会执行下一个
good bother:xiaoniao
this is over
6.497815370559692   #2+1+3+主程序执行时间

改变一下位置

from multiprocessing import process
import time,os,random
def func(name,hour):
    print("a lifelong friend:%s,%s"% (name,os.getpid()))
    time.sleep(hour)
    print("good bother:%s"%name)
start = time.time()
if __name__ == "__main__":
    p = process(target=func,args=('kebi',2))
    p1 = process(target=func,args=('maoxian',1))
    p2 = process(target=func,args=('xiaoniao',3))
    p.start()
    p1.start()
    p2.start()
    p.join()   #需要2秒
    p1.join()  #到这时已经执行完
    p2.join()   #已经执行了2秒，还要1秒
    print("this is over")
    print(time.time() - start)

#执行结果

a lifelong friend:kebi,13520
a lifelong friend:maoxian,11612
a lifelong friend:xiaoniao,17064  #几乎是同时开启执行
good bother:maoxian
good bother:kebi
good bother:xiaoniao
this is over
3.273620367050171  #以最长时间的为主

6.其它属性和方法

from multiprocessing import process
import time
def func(name):
    print("work start:%s"% time.ctime())
    time.sleep(2)
    print("work end:%s"% time.ctime())

if __name__ == "__main__":
    p = process(target=func,args=('kebi',))
    p.start()
    p.terminate()  #将进程杀死，而且必须放在start()后面，与daemon的功能类似

#执行结果
this is over

from multiprocessing import process
import time
def func(name):
    print("work start:%s"% time.ctime())
    time.sleep(2)
    print("work end:%s"% time.ctime())

if __name__ == "__main__":
    p = process(target=func,args=('kebi',))
    # p.daemon = true
    print(p.is_alive())
    p.start()
    print(p.name)   #获取进程的名字
    print(p.pid)    #获取进程的pid
    print(p.is_alive())  #判断进程是否存在
    print("this is over")