4/24 同一程序执行多次就是多个进程/开启子进程的两种方式/进程的内存空间相互硬件隔离/父进程等待子进程结束/进程对象的其他属性/僵尸进程与孤儿进程...

1 同一程序执行多次就是多个进程

　　一个py文件执行多次就是多个进程，其他的程序也是这样的。执行多次就是多个进程。

2 开启子进程的两种方式

　　共同之处就是，都是使用Process这个类。2 在windows系统里面必须使用if __name__='__main__'：这个来分割父进程来子进程

　　方式一是定义函数，然后再子进程里面调用Process这个类。p是Process，这个类的对象。

from multiprocessing import Process
import time
def task(name):
    print('%s is running' %name)
    time.sleep(3)
    print('%s is done' %name)
if __name__ == '__main__':
    # 在windows系统之上，开启子进程的操作一定要放到这下面
    # Process(target=task,kwargs={'name':'egon'})
    p=Process(target=task,args=('egon',))
    p.start() # 向操作系统发送请求，操作系统会申请内存空间，然后把父进程的数据拷贝给子进程，作为子进程的初始状态
    print('======主')

　　方式二 是定义类，然后把Process这个定义为父类。在子进程里面直接使用父进程里面定义的类，来调用父类的父类里面的属性。

from multiprocessing import Process
import time

class MyProcess(Process):
    def __init__(self,name):
        super(MyProcess,self).__init__()
        self.name=name

    def run(self):
        print('%s is running' %self.name)
        time.sleep(3)
        print('%s is done' %self.name)


if __name__ == '__main__':
    p=MyProcess('egon')
    p.start()
    print('主')

3进程的内存空间相互硬件隔离

 

　　在启动父进程和子进程以后，他们的内存地址是不一样的。进程和进程之间的内存地址是在硬件就相互隔离了。

如下代码在子进程里面，X永远是从全局名称里面查找X。X=0是在函数里面的。子进程里面的两个print都是父类的代码。

　　子类的代码是p.start（）这个对象发一个信号给操作系统的。然后操作系统根据这个信号申请一个内存地址去执行这个进程。

　　p=Process（target=task）这个代码的意思是把if __name__='__main__'：以上父进程的代码复制到我的子进程里面来，然后有执行的代码先执行，执行完去调用task这个函数。

　　子进程的代码就是父类里面的代码加执行task这个函数。有执行代码，就执行

　　代码是从上而下执行。

from multiprocessing import Process
import time

x=1000

def task():
    time.sleep(3)
    global x
    x=0
    print('儿子死啦',x)

print(x)
if __name__ == '__main__':
    print(x)
    p=Process(target=task)
    p.start()
    time.sleep(5)
    print(x)

4 父进程等待子进程结束

p.join()这个的意思就是等子进程结束了以后才执行p.join()以下的父进程的代码。

进程结束以后，然后操作系统会回收资源。删除内存地址里面进程。这才叫真正的结束进程。

而且p.start（）只是发信号给操作系统，而不是去执行进程。操作系统会收到大量的信号，然后会随机进行，并不是按照顺序去执行。具体可以看for2

from multiprocessing import Process
import time

x=1000

def task():
    time.sleep(3)
    global x
    x=0
    print('儿子死啦',x)


if __name__ == '__main__':
    p=Process(target=task)
    p.start()

    p.join() # 让父亲在原地等
    print(x)

for 2

from multiprocessing import Process
import time,random
x=1000
def task(n):
    print('%s is runing' %n)
    time.sleep(n)

if __name__ == '__main__':
    start_time=time.time()
    p_l=[]
    for i in range(1,4):
        p=Process(target=task,args=(i,))
        p_l.append(p)
        p.start()

    for p in p_l:
        p.join()
    print('主',(time.time() - start_time))

5进程对象的其他属性

os.getpid 可以查看在windows里面进程的PID

os.getppid 可以查看在windows里面父进程的PID

p1.pid 可以查看这个自己进程的PID

from multiprocessing import Process
import time,random
x=1000
def task(n):
    print('%s is runing' %n)
    time.sleep(n)
if __name__ == '__main__':
    start_time=time.time()
    p1=Process(target=task,args=(1,),name='任务1')
    p1.start()
    print(p1.pid)
    print('主')

6僵尸进程与孤儿进程

在linux中，子进程结束进程，还保留着基本的信息给父类可以查看。父类在结束的时候会统一回收这些信息。孤儿进程就是父进程结束了，但是子进程没有结束。那子进程就会有init这个老祖宗老来接手。

僵尸进程是有害的，不会占用内存地址，但是PID号是有限的。大量的产生会无法开启其他的进程。孤儿进程是无害的。因为会有init接手。

转载于:https://www.cnblogs.com/seanliang/p/8931878.html