python----进程拓展

1. 获取进程以及父进程的pid

   进程在内存中开启多个,操作系统如何区分这些进程?每个进程都有一个唯一标识,

   1. 在终端查看进程的pid.

   2. 在终端查看执行的进程pid

   3. 通过代码查看pid

      import os
      import time
      print(f'子进程:{os.getpid()}')
      print(f'父进程:{os.getppid()}')
      time.sleep(5000)
      

2. 验证进程之间的数据隔离

   from multiprocessing import Process
   import time
   x = 1000
   def task(name):
        print(name)
        global x
        x = 2
   if __name__ == '__main__':
        p1 = Process(target=task,args=('太白',))
        p1.start()
        time.sleep(3)
        print(f'主进程:{x}')
   

   # 上面已经验证了 子进程与父进程之间的空间隔离.,要验证初始变量是否是一个id.
   # 数字-5~256 主进程子进程是沿用同一个.
   from multiprocessing import Process
   import time
   x = 1000
   #x = 255
   def task(name):
        print(f'子进程:{id(x)}')
   if __name__ == '__main__':
        print(f'主进程:{id(x)}')
        p1 = Process(target=task,args=('太白',))
        p1.start()
        time.sleep(3)
   

3. join方法

   join 等待,主进程等待子进程结束之后,在执行
    # p1, p2, p3 三个子进程运行的先后顺序不定.
    # start只是通知一下操作系统,三个start几乎同一时刻发给操作系统,
    # 操作系统调用cpu先运行谁,谁先执行.
    join并不是串行.
   
   from multiprocessing import Process
   import time
   def task(name,sec):
       time.sleep(sec)
       print(f'{name} is running')
   if __name__ == '__main__':
       p1 = Process(target=task,args=('李业',3))
       p2 = Process(target=task, args=('怼哥', 2))
       p3 = Process(target=task, args=('ma', 1))
       start_time = time.time()
       p1.start()
       p2.start()
       p3.start()
       p1.join()
       p2.join()
       p3.join()
       print(f'===主进程:{time.time()-start_time}之后,执行')
   

4. 进程对象的其他属性

   from multiprocessing import Process
   import time
   def task(name):
       print(f'{name} is running')
       time.sleep(3)
       print(f'{name} is done')
   if __name__ == '__main__':
        p = Process(target=task,args=('怼哥',) ,name='任务1')  # name给进程对象设置name属性
        p.start()
        print(p.pid)  # 获取进程pid号
        print(p.name)
        time.sleep(1)
        p.terminate() # 终止(结束)子进程
        #terminate 与 start一样的工作原理: 都是通知操作系统终止或者开启一个子进程,内存中终止或者开启(耗费时间)
        time.sleep(1)
        print(p.is_alive())  # 判断子进程是否存活
        # 只是查看内存中p子进程是否运行.
        print('===主进程')
   

5. 僵尸进程与孤儿进程

   # linux(mac)环境下才强调的两个概念,windows下没有.
   # 面试官会问到这两个概念.
   from multiprocessing import Process
   import time
   import os
   def task(name):
       print(f'{name} is running')
       print(f'子进程开始了:{os.getpid()}')
       time.sleep(50)
   if __name__ == '__main__':
       for i in range(100000):
           p = Process(target=task,args=('怼哥',))
           p.start()
       print(f'主进程开始了:{os.getpid()}')
   # 主进程是子进程的发起者,按理说,主进程不会管子进程是否结束,对于结束来说,两个进程是没有任何关系的.
   # 但是通过代码我们发现: 主进程并没有结束,实际上你的主进程要等到所有的子进程结束之后,主进程在结束.
   # 父进程为什么不关闭?
   # 此时主进程形成了僵尸进程:
   # 内存中只包含: 主进程的pid,以及子进程的开启时间,结束时间. 至于主进程的代码以及文件,数据库数据等等全部消失.
   # 因为主进程要进行收尸环节.
   # 利用这个waitepid()方法,对所有的结束的子进程进行收尸.
   # 孤儿进程: 此时如果主进程由于各种原因,提前消失了,它下面的所有的子进程都成为孤儿进程了.
   #谁给孤儿进程收尸?  一段时间之后, init就会对孤儿进程进行回收.
   # 孤儿进程无害,如果僵尸进程挂了,init会对孤儿进程进行回收.
   # 僵尸进程有害?
   # 父进程(僵尸进程)无限的开启子进程,递归的开启,子进程越来越多,僵尸进程还没有结束,
   # 导致进程会越来越多,占用内存.
   
   

6. 守护进程

   # 守护: 我守护者你,你要是死了,我就跟你一起.
   # 子进程对父进程可以进行守护.
   # 生产者消费者模型会讲到.
   from multiprocessing import Process
   import time
   import os
   def task(name):
       print(f'{name} is running')
       print(f'子进程开始了:{os.getpid()}')
       time.sleep(50)
   if __name__ == '__main__':
       p = Process(target=task,args=('怼哥',))
       p.daemon = True  # 将p子进程设置成守护进程,守护主进程,只要主进程结束,子进程无论执行与否,都马上结束.
       p.start()
       time.sleep(2)
       print(f'主进程开始了:{os.getpid()}')