python启动进程_Python开启进程的2中方式

知识点一：进程的理论

进程：正在进行的一个程序或者说一个任务，而负责执行任务的则是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 importProcessimporttimedeftask(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 importProcessimporttimeclassMyprocess(Process):#辅助理解，

#def __init__(self,x):

#super().__init__()#保留原有Process类里面的方法

#self.name=x #***如果要自定义传参，self.name=x必须要放到super()._init_()下面

#

defrun(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 importProcessimporttime

x=100

deftask():globalx

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

importtimeimportosfrom multiprocessing importProcessdeftask(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()

importtimefrom multiprocessing importProcessdeftask(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('主')