并发编程 - 进程 - 1.开启子进程的两种方式/2.查看pid/3.Process对象的其他属性或方法/4.守护进程

1.开启子进程的两种方式:

 # 方式1：
 from multiprocessing import Process
 import time

 def task(name):
     print('%s is running'%(name))
     time.sleep(2)
     print('%s is done'%name)

 if __name__ == '__main__':
     # p = Process(target=task,kwargs={'name':'子进程1'})
     p = Process(target=task,args=('子进程1',))
     p.start()  # 仅仅只是给os发了一个信号

     print('主')
 '''
 主
 子进程1 is running
 子进程1 is done
 '''

 # 方式二：
 from multiprocessing import Process
 import time

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

     def run(self):  # 只能叫run
         print('%s is running'%(self.name))
         time.sleep(2)
         print('%s is done'%self.name)

 if __name__ == '__main__':
     p = MyProcess('子进程1')
     p.start()

     print('主')

 '''
 主
 子进程1 is running
 子进程1 is done
 '''

2.查看pid:

 from multiprocessing import Process
 import time
 import os

 def task(name):
     print('%s is running'%(name),os.getpid(),'parent:',os.getppid())
     time.sleep(2)
     print('%s is done'%name,os.getpid(),'parent:',os.getppid())

 if __name__ == '__main__':
     # p = Process(target=task,kwargs={'name':'子进程1'})
     p = Process(target=task,args=('子进程1',))
     p.start()  # 仅仅只是给os发了一个信号

     print('主',os.getpid(),'parent:',os.getppid())

 '''
 主 53400 parent: 12480  # pycharm的pid
 子进程1 is running 51432 parent: 53400
 子进程1 is done 51432 parent: 53400
 '''
 '''
 cmd:
     tasklist | findstr pycharm
     pycharm64.exe                12480 Console                    1    776,848 K
 '''
 '''
 linux:
     ps aux | grep pycharm
     bj        30819  0.0  0.0  21312   976 pts/1    R+   12:57   0:00 grep --color=auto pycharm
 '''

 '''
 僵尸进程与孤儿进程：
     如果父进程一直不死，子进程变成了僵尸进程后一直占着pid ,有害！
     父进程死之前，要wait()...回收僵尸进程的pid
     孤儿进程，父进程先死了，linux中最大的父进程init进程会回收孤儿进程的pid
         孤儿进程无害！最后init进程会回收！
         如果父进程不死，僵尸进程有害，一直占着pid

 '''

3.Process对象的其他属性或方法：

 # 1个子进程 join 方法：
 from multiprocessing import Process
 import time
 import os

 def task(name):
     print('%s is running'%(name),os.getpid(),'parent:',os.getppid())
     time.sleep(2)
     print('%s is done'%name,os.getpid(),'parent:',os.getppid())

 if __name__ == '__main__':
     p = Process(target=task,args=('子进程1',))
     p.start()  # 仅仅只是给os发了一个信号

     p.join()   # 主进程等待子进程的运行完成
     print('主',os.getpid(),'parent:',os.getppid())
     print(p.pid)  # 子进程结束了，但是变成了僵尸进程，子进程的pid 还存在
 """
 子进程1 is running 43680 parent: 46512
 子进程1 is done 43680 parent: 46512
 主 46512 parent: 12480
 43680
 """
 """
 主进程结束了，基于它的子进程才会结束，即僵尸进程的pid才会被回收！
 """

 # 多个子进程join方法 并行
 from multiprocessing import Process
 import time
 import os

 def task(name,n):
     print('%s is running'%(name))
     time.sleep(n)

 if __name__ == '__main__':
     start = time.time()
     p1 = Process(target=task,args=('子进程1',5))
     p2 = Process(target=task,args=('子进程2',3))
     p3 = Process(target=task,args=('子进程3',2))
     p_l = [p1,p2,p3]
     # p1.start()  # 仅仅只是给os发了一个信号
     # p2.start()
     # p3.start()
     for p in p_l:
         p.start()

     # p1.join()  # 主进程在等... 等的是最长的那个时间 5 3 2
     # p2.join()  # 这里任然是并发
     # p3.join()
     for p in p_l:
         p.join()

     print('主',(time.time()-start))
 '''
 主 34504 parent: 12480
 子进程1 is running 51732 parent: 34504
 子进程3 is running 48864 parent: 34504
 子进程2 is running 16240 parent: 34504
 '''
 '''
 子进程3 is running 46212 parent: 35732
 子进程1 is running 1528 parent: 35732
 子进程2 is running 50244 parent: 35732
 主 35732 parent: 12480
 '''
 """
 子进程1 is running
 子进程2 is running
 子进程3 is running
 主 5.094129323959351  # 等的是5秒 任然是并发，不是串行。
 """

 # 多个子进程join方法 串行
 from multiprocessing import Process
 import time
 import os

 def task(name,n):
     print('%s is running'%(name))
     time.sleep(n)

 if __name__ == '__main__':
     start = time.time()
     p1 = Process(target=task,args=('子进程1',5))
     p2 = Process(target=task,args=('子进程2',3))
     p3 = Process(target=task,args=('子进程3',2))

     p1.start()
     p1.join()
     p2.start()
     p2.join()
     p3.start()
     p3.join()

     print('主',(time.time()-start))  # 这个时候就是 串行
 """
 子进程1 is running
 子进程2 is running
 子进程3 is running
 主 10.235251665115356
 """

 # 其他方法：is_alive() terminate() pid name
 from multiprocessing import Process
 import time
 import os

 def task(name):
     print('%s is running'%(name),os.getpid())
     time.sleep(2)

 if __name__ == '__main__':
     # p = Process(target=task,args=('子进程1',))
     # p.start()
     # print(p.is_alive())
     # p.join()
     # print('主')
     # print(p.pid)   # 子进程即僵尸进程pid
     # print(p.is_alive())  # 查看进程是否还活着

     p = Process(target=task,name='sub-process',args=('子进程1',))
     p.start()
     # p.terminate()  # 给os 发了个信号，还没来的及杀死子进程
     # time.sleep(2)
     # print(p.is_alive()) # True --> 加了time.sleep(2) --> False
     print('主')

     print(p.name,p.pid)
 """
 主
 Process-1 48456
 子进程1 is running 48456
 """
 """
 主
 sub-process 43556
 子进程1 is running 43556
 """

4.守护进程

 """
 开进程的目的：并发任务；假设任务在主进程死后没意义存在了，就设为守护进程。
 守护进程：
            0.p.daemon = True
            1.主进程结束时，守护进程就完了
            2.守护进程一定要在子进程start()前设置
            3.不允许在守护进程内在开子进程
 """
 from multiprocessing import Process
 import time

 def task(name):
     print('%s is running'%name)
     time.sleep(2)
     # p = Process(target=time.sleep,args=(3,))
     # p.start()

 if __name__ == "__main__":
     p = Process(target=task,args=('子进程1',))
     p.daemon = True  # 守护进程 主结束时，子进程就完了 ，守护进程一定要在子进程start() 前设置
     p.start()
     p.join()
     print('主')
 """
 主
 """
 """
 子进程1 is running
 主
 """

 """练习题："""
 # 思考下列代码的执行结果有可能有哪些情况？为什么？
 from multiprocessing import Process
 import time

 def foo():
     print(123)
     time.sleep(1)
     print("end123")

 def bar():
     print(456)
     time.sleep(3)
     print("end456")

 if __name__ == '__main__':
     p1=Process(target=foo)
     p2=Process(target=bar)

     p1.daemon=True  # 主进程死后，代码执行完毕，守护进程就死了
     p1.start()
     p2.start()
     print("main-------")  # 只要这里一运行，守护进程就完了

 """
 main-------
 456
 end456
 """