创建进程和多进程 process join p.daemon terminate

一.创建一个进程

import os
import time
from multiprocessing import Process
def func():
    print('heiheihei')
    time.sleep(1)
    print(os.getpid())
    print('hahaha')

if __name__ == '__main__':
    print('**',os.getpid())
    p = Process(target=func)  #target目标
    p.start()    #启动一个进程
    print('**',os.getpid())

二.给进程加参数

1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号
3.kwargs表示调用对象的字典,kwargs={'name':'egon','age':18}

import os
from multiprocessing import Process
def func(args,args2):
    print(args,args2)
    print("子进程是：%s" % (os.getpid()))
if __name__ == "__main__":
    p=Process(target=func,args=("jerd","alex"))  #args是元祖
    p.start()
    print("***")
    print("父进程是：%s"%(os.getpid()))
    print("父进程的父进程是：%s" % (os.getppid()))  #父进程的父进程是pycharm

三.多进程join的方法

p.join()是感知一个子进程的结束,将异步的程序改为同步

多个进程同时运行（注意，子进程的执行顺序不是根据启动顺序决定的）
子进程打开后不能控制子程序哪个先执行。由操作系统给的时间片决定

父进程和子程序同时进行。子程序异步

import os
import time
from multiprocessing import Process
def func(args1,args2):
    print(args1 * "*"  )
    time.sleep(2)
    print(args2 * "**"  )
if __name__ == "__main__":
    for i in range(5):
        p=Process(target=func,args=(i,i))  #args是元祖
        p.start()
    print("父进程")  

父进程和子程序同时进行。子程序同步

import time
from multiprocessing import Process
def func(args1,args2):
    print(args1 * "*"  )
    time.sleep(2)
    print(args2 * "**"  )
if __name__ == "__main__":
    for i in range(5):
        p=Process(target=func,args=(i,i))  #args是元祖
        p.start()
        p.join()
    print("父进程")  

父进程最后执行且子进程异步

import time
from multiprocessing import Process
def func(args1,args2):
    print(args1 * "*"  )
    time.sleep(2)
    print(args2 * "**"  )
if __name__ == "__main__":
    p_list=[]
    for i in range(5):
        p=Process(target=func,args=(i,i))  #args是元祖
        p_list.append(p)
        p.start()
    for p in p_list:p.join()  #[p.join() for p in p_list[])
    print("父进程")   

四.创建多进程 继承的方法

import os
from multiprocessing import Process
class MyProcess(Process):
    def run(self):  #正是它去调用target指定的函数
        print(os.getpid())
if __name__ == "__main__":
    p1=MyProcess()
    p1.start()
    p2 = MyProcess()
    p2.start()
    print("***",os.getpid())
# 自定义类 继承Process类
# 必须实现一个run方法,run方法中是在子进程中执行的代码
import time
from multiprocessing import Process
class MyProcess(Process):
    def __init__(self,arg1,arg2):
        super().__init__()  #必须调用父类的init。给父类添加上属性
        self.arg1=arg1
        self.arg2=arg2
    def run(self):   #正是它去调用target指定的函数
        print(self.pid)
        print(self.name)
        print(self.arg1)
        print(self.arg2)
if __name__ == "__main__":
    p=MyProcess(1,2)
    p.start()
    p2=MyProcess(3,4)
    p2.start()

五.多进程之间的数据隔离

进程之间的数据时隔离开的，互不影响

import os
from multiprocessing import Process
def func():
    global n
    n=0
    print(os.getpid(),n,id(n))  #3212 0 2010607040
if __name__ == "__main__":
    n=100
    p=Process(target=func)
    p.start()
    print(os.getpid(),n,id(n))  #13960 100 2010610240

六.守护进程 p.daemon = True

守护进程会随着主进程的代码执行完毕而结束
主进程创建守护进程
其一：守护进程会在主进程代码执行结束后就终止
其二：守护进程内无法再开启子进程,否则抛出异常

import time
from multiprocessing import Process
def func():
    while True:
        time.sleep(0.2)
        print('hahaha')
if __name__ == "__main__":
    p = Process(target=func)
    p.daemon = True  # 设置子进程为守护进程
    p.start()
    i = 0
    while i<2:
        print('我是socket server')
        time.sleep(1)
        i+=1

七.结束进程 p.terminate()

在主进程内结束一个子进程 p.terminate() (特美内t）
    #结束一个进程不是在执行方法之后立即生效,需要一个操作系统响应的过程
检验一个进程是否活着的状态 p.is_alive()
p.name p.pid 这个进程的名字和进程号

import time
from multiprocessing import Process
def func():
    print("heiheihie")
    time.sleep(8)
    print('hahaha')
if __name__ == "__main__":
    p = Process(target=func)
    p.start()
    p.terminate()  # 结束一个子进程
    print(p.is_alive())  #此时进程还没有立马结束
    print(p.name)
    i = 0
    while i<2:
        print('我是socket server')
        time.sleep(1)
        i+=1
    print(p.is_alive())  #此时进程结束