进程

进程

孤儿进程：父进程执行完毕，子进程还未结束，这种子进程被称为孤儿进程。

三种情况，父进程等着子进程都执行完毕，将执行完毕的僵尸进城回收，（无害）；父进程执行完毕，子进程还在继续执行，这种情况是程序都要被init进程接管并回收（无害）；父进程一直执行，造成大量的的僵尸进程，占用大量的pid号（补充：pid号是有限的）（有害）。

第三种情况解决方案：强制结束父进程。

join的用法

1、阻塞住主进程再等待子进程结束，然后再往下执行，（了解的是：内部会待用wait（））

from multiprocessing import Processimport timedef foo():
  print('进程  start ')
  time.sleep(1)
  print('进程  end ')
  if __name__ == '__main__':
    p = Process(target=foo)
    p.start() 
    #     核心需求就是    
    time.sleep(5)
    p.join()      
    print('主进程')

2、

from multiprocessing import Process
import time
def foo(x):    
  print('进程  start ')
  time.sleep(x)
  print('进程  end ')
if __name__ == '__main__':
  p1 = Process(target=foo,args=(1,))
  p2 = Process(target=foo,args=(2,))
  p3 = Process(target=foo,args=(3,))
  start = time.time()
  p1.start() 
      p2.start() 
      p3.start() 
      #    # 核心需求就是    # 
      time.sleep(5)   
      p3.join() #1s    
      p1.join() #1s    
      p2.join() #1s    # 总时长：按照最长的时间计算多一点。    
      end = time.time()   
      print(end-start) #3s多 or 6s多  ？  正解：3s多    
      print('主进程')

3、

from multiprocessing import Process
import time


def foo(x):
    print(f'进程{x}  start ')
    time.sleep(x)
    print(f'进程{x}  end ')


if __name__ == '__main__':
    p1 = Process(target=foo,args=(1,))
    p2 = Process(target=foo,args=(2,))
    p3 = Process(target=foo,args=(3,))
    start = time.time()
    p1.start() #
    p1.join() #
    p2.start() #
    p2.join() #
    p3.start() #
    p3.join() #
    # 不如不开，直接穿行调用函数反而快
    foo(1)
    foo(2)
    foo(3)
    # 核心需求就是
    time.sleep(5)
    p3.join() #1s
    p1.join() #1s
    p2.join() #1s
    # 总时长：按照最长的时间计算多一点。
    end = time.time()
    print(end-start) #3s多 or 6s多  ？  正解：3s多
    print('主')

from multiprocessing import Process
import time


def foo(x):
    print(f'进程{x}  start ')
    time.sleep(x)
    print(f'进程{x}  end ')


if __name__ == '__main__':
    start = time.time()
    p_list = []
    for i in range(1, 4):
        p = Process(target=foo, args=(i,))
        p.start()
        p_list.append(p)
    print(p_list)
    for p in p_list:
        p.join()
    end = time.time()
    print(end-start)  # 3s多 or 6s多  ？  正解：3s多
    print('主进程')

Process的其他用法

from multiprocessing import Process,current_process
import time,os

def task():

    print('子进程 start')
    print('在子进程中查看自己的pid',current_process().pid) # 在子进程中查看自己的pid
    print('在子进程中查看父进程的pid',os.getppid()) #
    time.sleep(200)
    print('子进程 end')

if __name__ == '__main__':

    p = Process(target=task)
    p.start()
    print('在主进程查看子进程的pid',p.pid) # 一定要写在 start()之后
    print('主进程的pid',os.getpid())
    print('主进程的父进程pid',os.getppid())
    print('主')

站在当前进程的角度我们需要知道

os.getpid() #获取当前进程的pid;

os.getppid() # 获取当前进程的父进程pid

子进程对象.pid #获取当前进程的子进程pid

守护进程：

本质还是一个子进程，但是当主进程的代码执行完毕守护进程直接结束，此时主进程可能没有结束