进程创建 033

一 . 创建进程的两种方法 : 

　　1 第一种方法: 利用Process直接生成

　　　　　　p1 = Process(target = fun1,args=(1,))

　　　　　　p1.start()

from multiprocessing import Process
import os
def func1(n):
    time.sleep(1)
    print(n)
def func2(n):
    time.sleep(1)
    print(n)
def func3(n):
    time.sleep(1)
    print(n)
def func4(n):
    time.sleep(1)
    print(n)
if __name__ == '__main__':
    p1 = Process(target=func1, args=(1,))  # 创建一个新进程  第一种方式
    p2 = Process(target=func2, args=(2,))
    p3 = Process(target=func3, args=(3,))
    p4 = Process(target=func4, args=(4,))
    p1.start()  # 给cpu发送指令 告诉cpu已准备就绪 等待被调用
    p2.start()
    p3.start()
    p4.start()
    print('主程序结束')

　　2 第二种方法:自定义一个类 继承 process 类

　　　　重写run方法,传参数的时候要写init 但是要注意 在init方法中运用父类的init方法

　　　　Windows 下写代码开启子进程时 必须写上 if __name__ == '__main__':

from multiprocessing import Process
class MyProcess(Process):
    def __init__(self,n,name):
        super().__init__()
        self.n = n
        self.name = name
    def run(self): # 必须用run定义
        print('子进程的进程id',os.getpid())
        print('你看看',self.n)
if __name__ == '__main__':
    p1 = MyProcess(100,name='子进程1')
    p1.start()
    print('p1.name', p1.name)
    print('p1.pid', p1.pid)
    print('主进程结束')

二 两种参数形式

　　　　args= (1,)     kwargs = {'n':1} 必须和执行任务需要的形参相同 不然传不进去

三 验证进程之间是空间隔离

# 定义全局变量
global_num = 100
def func1():
    global global_num  #引入全局变量
    global_num = 0 # 将全局变量改为0
    print('子进程全局变量', global_num)
if __name__ == "__main__":
    p1 = Process(target=func1,)
    p1.start()
    time.sleep(1)
    print('主进程的全局变量', global_num)
# 运行结果如下:
# 子进程全局变量 0
# 主进程的全局变量 100

　　　　子进程的结果表明将全局变量修改为0 但主进程结果仍是100 证明进程之间是相互隔离的 不共享资源

四 join 方法 让主进程 加上join的地方等待 (即阻塞) 等待子进程执行完之后,再继续往下执行 我的主进程 好多时候 , 我们主进程需要子进程的执行结果 所以必须要等待.join感觉就像是将子进程和主进程拼接起来一样 将异步改为同步进行 

from multiprocessing import Process
def fun1(n):
    time.sleep(1)
    print(n)
if __name__ == '__main__':
    pro_list = []
    for i in range(10):
        p1 = Process(target=fun1,args=(i,))
        p1.start()
        pro_list.append(p1)
    for p in pro_list:
        p.join()
    print('主进程结束')
# 结果就是10个子进程结束之后才会结束主进程

或者
from multiprocessing import Process
# 验证join方法
global_num = 100
def func1():
    global global_num  #引入全局变量
    global_num = 0
    print('子进程全局变量', global_num)
if __name__ == "__main__":
    p1 = Process(target=func1,)
    p1.start()
    p1.join() # 阻塞住 等待p1子进程执行结束 主进程程序才能从这里继续往下执行
    print('主进程的全局变量', global_num)

五 验证并发的执行时间 

六 for 循环在多进程中的应用 

七 关闭进程但是它只是给操作系统发个关闭进程的信号 实际操作是操作系统关闭的

僵尸进程和孤儿进程(了解)

import time
import os
from multiprocessing import Process
def func1():
    time.sleep(10)
    print(os.getpid())
    print('子进程')
if __name__ == '__main__':
    p1 = Process(target=func1,)
    p1.start()
    print('主进程的ID',os.getpid())
    print('主进程结束')

守护进程 (应用开启qq)

import time
import os
from multiprocessing import Process
def func1():
    time.sleep(5)
    print(os.getpid())
    print('子进程')
if __name__ == '__main__':
    p1 = Process(target=func1,)
    # 将p1子进程设置为守护进程
    p1.daemon = True   # 如果设为True 代表p为后台运行的守护进程, 当p的父类进程终止时,p也随之终止,并且设定为True后,p不能创建自己的
#新进程 , 必须在p.start()之前设置  也不能再创建子进程
    p1.start()
    print('主进程结束')

 十一 子进程不能input