知识点一：进程的理论
进程：正在进行的一个程序或者说一个任务，而负责执行任务的则是CPU
进程运行的的三种状态:
1.运行：（由CPU来执行，越多越好，可提高效率）
2.阻塞：（遇到了IQ，3个里面可以通过减少阻塞有效的来提高效率）
3.就绪：（等待CPU来执行的过程）
知识点二：开启进程的两种方式
开启进程：开启进程就是将父进程里面串行执行的程序放到子进程里，实现并发执行，这个过程中，会将父进程数据拷贝一份到子进程。
运行角度：是2个进程
注意：子进程内的初始数据与父进程的一样，如果子进程被创建了被运行了，那么
子进程里面数据更改对父进程无影响，2个进程是存在运行的
方式一：通过调用multiprocessing模块下面的Process类方法
#方式一：通过调用multiprocessing模块下面的Process类方法
'''
p = Process(target=task, args=('子进程',)) ：
target=task:指定执行任务的目标是谁 args:后面跟元组，是给target指定函数传的参数
p=Process(..)相当于是对类Process进行实例化得到了P对象
'''
from multiprocessing import Process
import time
def task(x):
print("%s is runnin"%x) #子进程打印输出
time.sleep(3)
print('%s is done'%x) #子进程打印输出
if __name__ == '__main__': #开进程要统一放到main方法的下面
p=Process(target=task,args=('子进程',))
p.start()
print('主') #父进程的打印输出
'''
注意点：
1.p=Process(target=task,args=('子进程',))
这一步：只是在向操作系统发我要开启一个子进程的信号（具体开子进程的操作是由操作系统来完成的）
*所有这个过程中的时间也是不固定的
2.p.start()：
开启一个子进程
运行过程分析：
右键运行父类先运行起来(此时p.start()子类也已经在造了，但是会有时间延迟)-->print('主')-->
然后依次运行子进程里面内容;子进程 is runnin\子进程 is done
'''
方式二：借助process类，自定义一个类（继承Process），从而造一个对象
#方式二：借助process类，自定义一个类（继承Process），从而造一个对象
from multiprocessing import Process
import time
class Myprocess(Process):
#辅助理解，
# def __init__(self,x):
# super().__init__()#保留原有Process类里面的方法
# self.name=x #***如果要自定义传参，self.name=x必须要放到super()._init_()下面
#
def run(self):
print("%s is running" % self.name) #默认函数对象有name方法 ，结果为：Myprocess-1
time.sleep(3)
print('%s is done' % self.name)
if __name__ == '__main__':
# p=Myprocess('子进程1',) 开启init方式就可以自定义参数传值
p=Myprocess() #实例化Myprocess类调用了类面的init方法，得到了一个对象p
p1=Myprocess()
p.start() #p.run() 对象去调用了类里面的run方法，进而执行run里面的函数体代码
p1.start()
print('主')
以上2中方式的对比分析：
方式二：子类只能运行同一个run里面输出的方式（run名字是固定的，不能更改）
方式一：可以自定义多个task函数，并且写不同的输出内容，例如task1-->p1 task2-->p2...等等灵活性更高
父类、子类进程内存空间是彼此隔离的：
from multiprocessing import Process
import time
x=100
def task():
global x
x=11 #当子类已经建立成功时，子类里面对数据的变动，不会印象父类
print(x) #11
print('done')
if __name__ == '__main__':
p=Process(target=task)
p.start()
time.sleep(10) # 让父进程在原地等待10，是为了等父类先建立好，用于验证子类里面的变动不会影响父类的值
print(x) #打印时父类的，即全局的 100
知识点三：僵尸进程、孤儿进程
僵尸进程：（无害的）
子进程运行结束后，会保留进程的ID号等信息，
目的是为了父进程能查看子进程的状态，以及回收僵尸状态的子进程
孤儿进程：（无害的）
在子类没有运行完的情况下，父类先行结束，这种情况下，当子进程结束时，
状态就叫做孤儿进程，当然也会被系统层面上的孤儿院回收
有一种情况是有害的：
如果父类，不停的在造子类，父类一直不死，此时PID会占用过多，导致内存也会占用很多
这种情况是有害的
知识点四：进程对象相关的属性
1.PID接口查看
#查看PID应用：
# print(p.pid)：外面直接查看子类pid
#os.getpid()：在内部查看子类pid
#os.getpid()：在外面查看父类的pid
#os.getppid()：在里面查看父类的pid
import time
import os
from multiprocessing import Process
def task(x):
print('%s is running'%os.getpid()) #子进程内查看自己pid的方式
time.sleep(100)
print('子类下查看父类的id：%s'%os.getppid()) #查看父类的pid
time.sleep(100)
print('%s is done'%x)
if __name__ == '__main__':
p=Process(target=task,args=('子进程1',))
p.start()
print(p.pid,) #父进程内查看子类pid的方式
time.sleep(50)
print('父类下查看父类自己的id：',os.getpid())
print('主')
2.join()
import time
from multiprocessing import Process
def task(name,n):
print('%s is running'%name)
time.sleep(n)
print('%s is done'%name)
if __name__ == '__main__':
p1=Process(target=task,args=("进程1",1)) #用时1s
p2=Process(target=task,args=("进程2",2)) #用时1s
p3=Process(target=task,args=("进程3",3)) #用时1s
start_time=time.time()
p1.start()
# p1.join() #如果是这种情况就是总共6s左右了
p2.start()
# p2.join()
p3.start()
# p3.join()
# 让父进程在原地等待，等子进程在运行完毕后，才执行下一行代码（）
#注意：并不是串行，当第一秒在运行p1时，其实p2、p3也已经在运行，当1s后到p2时只需要再运行1s就到p3了，到p3也是一样。
p1.join()
p2.join()
p3.join()
stop_time=time.time() #3.2848567962646484总结
print(stop_time-start_time)
print('主')
