multiprocess模块

开启子进程的方式:
os.getpid()获取的是当前进程自己的pid
os.getppid()获取的是当前进程的父进程的pid

from multiprocessing import Process
import os
import time
def func(n):
    time.sleep(1)
    print("这里是儿子%s进程,儿子自己的pid是%s,儿子的父亲的pid是%s" %(n,os.getpid(),os.getppid()))
if __name__ == '__main__':
    p = Process(target=func,args=(1,))
    p.start()
    print("这里是父进程,父进程自己的pid是%s,父进程的父进程的pid是%s" % (os.getpid(),os.getppid()))

自定义类,以继承方式开启子进程
from multiprocessing import Process
class MyProcess(Process):
    def __init__(self):
        super(MyProcess, self).__init__()
    def run(self):
        print("继承方式开启子进程")
if __name__ == '__main__':
    p = MyProcess()
    p.start()
    p.run()
# p1.start()# 是指，解释器告诉操作系统，开启一个进程,属于就绪状态
# p1.run()# 是指告诉操作系统，现在马上执行这个子进程,属于执行状态


from multiprocessing import Process
class MyProcess(Process):
    def __init__(self,name):
        self.name = name
        super(MyProcess, self).__init__(name = self.name)    #执行父类的__init__方法
    def run(self):
        print("继承方式开启子进程,名字是%s" %(self.name))
if __name__ == '__main__':
    p = MyProcess("asdfg")
    p.start()


from multiprocessing import Process
class MyProcess(Process):
    def __init__(self,name):
        super(MyProcess, self).__init__()
        self.name = name
    def run(self):
        print("继承方式开启子进程,名字是%s" %(self.name))
if __name__ == '__main__':
    p = MyProcess("asdfg")
    p.start()

开启多个不同的子进程

from multiprocessing import Process
import time
import os
def func(i):
    time.sleep(1)
    print("这是子进程,pid是%s,父进程的pid是%s" % (os.getpid(),os.getppid()))
if __name__ == '__main__':
    for i in range(2):
        p = Process(target=func,args=(i,))
        p.start()
    print("这是父进程,pid是%s,父进程的pid是%s" % (os.getpid(),os.getppid()))

进程的常用方法

from multiprocessing import Process
import time
def func():
    time.sleep(3)
    print("这是子进程")
if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    time.sleep(1)
    print("这是父进程")
结果:
这是父进程
这是子进程

from multiprocessing import Process
import time
def func():
    time.sleep(3)
    print("这是子进程")
if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    time.sleep(5)
    print("这是父进程")
结果:
这是子进程
这是父进程

总结:当程序run时,首先执行if __name__ == '__main__':,然后实例化一个进程对象 p = Process(target=func)
,接着开启子进程p.start(),主进程和子进程同时进行,当主进程沉睡时间小于子进程则先执行主进程,反之则先执行子进程.

开启一个正常的子进程，父进程会等待子进程结束后，父进程(程序)才结束

from multiprocessing import Process
import time
def func():
    time.sleep(3)
    print("这是子进程")
if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    print("这是父进程")
结果:
这是父进程
这是子进程

 p.join()

是让主进程等待子进程执行完。
现象：主进程执行到这句话，主进程阻塞住，等待子进程执行

from multiprocessing import Process
import time
def func():
    time.sleep(3)
    print("这是子进程")
if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    p.join()
    time.sleep(1)
    print("这是父进程")
结果:
这是子进程
这是父进程

如何把父进程和子进程之间的关系变为同步或者异步？
父进程执行join，就会变成同步，不执行join，父进程和子进程就是异步的关系
join必须放在start()后边

from multiprocessing import Process
import time
def func():
    time.sleep(3)
    for i in range(10):
        print("这是子进程")
if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    p.join()
    time.sleep(1)
    for i in range(5):
        print("这是父进程")
结果:
这是子进程
这是子进程
这是子进程
这是子进程
这是子进程
这是子进程
这是子进程
这是子进程
这是子进程
这是子进程
这是父进程
这是父进程
这是父进程
这是父进程
这是父进程

from multiprocessing import Process
import time
def func():

    for i in range(10):
        time.sleep(1)
        print("这是子进程")
if __name__ == '__main__':
    p = Process(target=func)
    p.start()

    for i in range(5):
        time.sleep(1)
        print("这是父进程")
结果:
这是父进程
这是子进程
这是父进程
这是子进程
这是父进程
这是子进程
这是父进程
这是子进程
这是父进程
这是子进程
这是子进程
这是子进程
这是子进程
这是子进程
这是子进程

p.is_alive() 判断p进程是否还活着
 返回一个bool值，如果返回True，代表进程还活着,如果返回False，代表子进程死了
p.terminate() 杀死p进程

from multiprocessing import Process
import time
def func():
    time.sleep(1)
    print("这是子进程")
if __name__ == '__main__':
    p = Process(target=True)
    p.start()
    p.terminate()
    print("子进程是否还活着?",p.is_alive())
    print("子进程是否还活着?",p.is_alive())
    print("子进程是否还活着?",p.is_alive())
    time.sleep(1)
    print("子进程是否还活着?",p.is_alive())
结果:
子进程是否还活着? True
子进程是否还活着? True
子进程是否还活着? True
子进程是否还活着? False

进程的常用属性

from multiprocessing import Process
import time
import os
def func():
    time.sleep(1)
    print("这是子进程,pid是%s" %os.getpid())
if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    p.name = "asff"
    print("这是父进程,子进程的名字叫%s" % p.name)
    print("这是父进程,子进程的pid是%s" % p.pid)
    print("这是父进程,子进程是否是守护进程",p.daemon)
结果:
这是父进程,子进程的名字叫asff
这是父进程,子进程的pid是8672
这是父进程,子进程是否是守护进程 False
这是子进程,pid是8672

守护进程
将p进程设置为守护进程,必须要在start之前设置

from multiprocessing import Process
import time
def func():
    time.sleep(1)
    print("这是子进程")
if __name__ == '__main__':
    p = Process(target=func)
    p.daemon = True
    p.start()
    time.sleep(3)
    print("这是父进程")
结果:这是父进程
总结:守护进程：跟随着父进程的代码执行结束，守护进程就结束

守护进程的特点:不允许开启子进程

from multiprocessing import Process
import time

def func1():
    print("这是子进程的子进程")
def func():
    p = Process(target=func1)
    p.start()
    time.sleep(1)
    print("这是子进程")
if __name__ == '__main__':
    p = Process(target=func)
    p.daemon = True
    p.start()
    time.sleep(3)
    print("这是父进程")
结果:报错:daemonic processes are not allowed to have children

守护进程的用法

from multiprocessing import Process
import time

def func():
    for i in range(10):
        time.sleep(1)
        print(time.strftime("%H:%M:%S"))
if __name__ == '__main__':
    p = Process(target=func)
    p.daemon = True
    p.start()
    time.sleep(6)
    print("这是父进程")
结果:
16:15:17
16:15:18
16:15:19
16:15:20
16:15:21
这是父进程