并发编程----pid 数据隔离 jion 属性 僵尸孤儿 守护进程

pid 数据隔离 jion 属性 僵尸孤儿 守护进程

一,multiprocessing模块

• python中的多线程无法利用多核优势,如果想要充分地使用多核CPU的资源(os.cpu_count()查看),在python中大部分情况需要使用多进程.Python提供了multiprocessing.
• multiprocessing模块用来开启子进程,并在子进程中执行我们定制的任务(比如函数),该模块与多线程模块threading的编程接口类似.
• multiprocessing模块的功能众多: 支持子进程、通信和共享数据、执行不同形式的同步,提供了Process、Queue、Pipe、Lock等组件.
• 需要再次强调的一点是: 与线程不同,进程没有任何共享状态,进程修改的数据,改动仅限于该进程内.

二, Process类的介绍

• 创建进程的类:

  Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）
  
  强调：
  1. 需要使用关键字的方式来指定参数
  2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号
  

• 参数介绍:

  • group参数未使用,值始终为None
  • target表示调用对象,即子进程要执行的任务
  • args表示调用对象的位置参数元组
  • kwargs表示调用对象的字典
  • name为子进程的名称

• 方法介绍:

  • p.start(): 启动进程,并调用该子进程的p.run()
  • p.run(): 进程启动时运行的方法,正是它去调用target指定的函数,我们自定义类的类中一定要实现该方法
  • p.terminate(): 强制终止进程p,不会进行任何清理操作,如果p创建了子进程,该子进程就成了僵尸进程,使用该方法需要特别小心这种情况.如果p还保存了一个锁那么也将不会被释放,进而导致死锁
  • p.is_alive(): 如果p仍然运行,返回True
  • p.join([timeout]): 主线程等待p终止(强调: 是主线程处于等的状态,而p是处于运行的状态).timeout是可选的超时时间,需要强调的是,p.join只能join住start开启的进程,而不能join住run开启的进程.阻塞

• 属性介绍:

  • p.daemon: 默认值为False,如果设为True,代表p为后台运行的守护进程,当p的父进程终止时,p也随之终止,并且设定为True后,p不能创建自己的新进程,必须在p.start()之前设置

  • p.name: 进程的名称

  • p.pid: 进程的pid

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

      # 在终端查看进程的pid  tasklist(查看现阶段运行的所有进程)
      # 一个程序可以有多个进程
      # 在终端查看指定的进程的pid  tasklist| findstr pycharm
      # 通过代码查看pid
      import os
      print(os.getpid())  # 当前进程id
      print(os.getppid())  # 查看父进程id
      

• p.ppid: 父进程的pid

三, Process类的使用

一,创建开启子进程的两种方式

# 开启进程的2种方式
# 第一种方式
from multiprocessing import Process
import time
def task(name):
    print(f'{name} is running')
    time.sleep(9)
    print(f'{name} is done')

if __name__ == '__main__':  # windows必须在main下开启多进程
    p = Process(target=task, args=('子进程',))    # args一定是一个元组
    p.start()   # 通知操作系统在内存种开辟一个空间,将p这个进程放进去,让cpu执行
    print('===>主进程')
----------------------------------------------------
# 第二种方式
from multiprocessing import Process
import time
class MyProcess(Process):
    def __init__(self, name):
        super().__init__()  # 必须继承父类的init
        self.name = name

    def run(self):  # 必须是run
        print(f'{self.name} is running')
        time.sleep(9)
        print(f'{self.name} is done')

if __name__ == '__main__':
    p = MyProcess('子进程')
    p.start()
    print('===>主进程')

二,验证进程之间的空间隔离

from multiprocessing import Process
import time
x = 1000
def task():
    global x
    x = 2

if __name__ == '__main__':
    p1 = Process(target=task)
    p1.start()
    time.sleep(3)
    print('主进程:', x)
# 验证了数据隔离
# 只有数字-5~256,True,False在不同进程之间驻留,沿用同一个内存地址

三.进程对象的join方法

from multiprocessing import Process
import time
def task():
    print('子进程开始')
    time.sleep(3)
    print('子进程结束')

if __name__ == '__main__':
    p1 = Process(target=task)
    p1.start()
    time.sleep(4)
    print(' in 主进程')

# 上面的版本虽然达到了目的,但是真正的生产环境中,子进程结束的时间不定,需要用到join
-------------------------------------------------------
from multiprocessing import Process
import time
def task():
    print('子进程开始')
    time.sleep(3)
    print('子进程结束')

if __name__ == '__main__':
    p1 = Process(target=task)
    p1.start()
    p1.join()  # 告知主进程,p1进程结束之后,主进程再运行
    print(' in 主进程')
-------------------------------------------------------
# 开启多个子进程去验证
from multiprocessing import Process
import time
def task(n):
    print(f'{n}子进程开始')
    time.sleep(n)
    print(f'{n}子进程结束')

if __name__ == '__main__':
    time_start = time.time()
    p1 = Process(target=task, args=(1,))
    p2 = Process(target=task, args=(2,))
    p3 = Process(target=task, args=(3,))
    p1.start()
    p2.start()
    p3.start()
    p1.join()
    p2.join()
    p3.join()
    print(f'主进程在{time.time() - time_start}后执行')
# 验证了如此写join并不是串行,主进程会等最长的结束再执行
# p1,p2,p3谁先运行并不确定
------------------------------------------------------
# 下面的结果是什么? 为什么?
from multiprocessing import Process
import time
def task(n):
    print(f'{n}子进程开始')
    time.sleep(n)
    print(f'{n}子进程结束')

if __name__ == '__main__':
    time_start = time.time()
    p1 = Process(target=task, args=(1,))
    p2 = Process(target=task, args=(2,))
    p3 = Process(target=task, args=(3,))
    p1.start()
    p1.join()
    print(111)
    p2.start()
    p2.join()
    print(222)
    p3.start()
    p3.join()
    print(333)
    print(f'主进程在{time.time() - time_start}后执行')
# p1,p2,p3是串行
-------------------------------------------------------------------------------------
from multiprocessing import Process
import time
def task(n):
    print(f'{n}子进程开始')
    time.sleep(n)
    print(f'{n}子进程结束')

if __name__ == '__main__':
    time_start = time.time()
    lst = []
    for el in range(1, 4):
        p = Process(target=task, args=(el,))
        lst.append(p)
        p.start()
    for p in lst:
        p.join()
    print(f'主进程在{time.time() - time_start}后执行')

四.进程对象的其他属性

from multiprocessing import Process
import time
def task():
    print('子进程开始')
    time.sleep(3)
    print('子进程结束')
if __name__ == '__main__':
    p1 = Process(target=task, name='任务1')   # name给进程对象设置name属性
    p1.start()
    print(p1.pid)  # 获取进程的pid号
    print(p1.name)
    p1.terminate()  # 终止(杀死)子进程,强制结束
    # terminate 与 start一样的工作原理:
    # 都是通知操作系统终止或开启一个子进程,内存中终止或开启,
    # 这是需要耗费时间的
    time.sleep(1)
    print(p1.is_alive())   # 判断子进程是否存活
    # is_alive 只是查看内存中子进程是否在运行
    print('In 主进程')

五.僵尸进程和孤儿进程

# 僵尸进程
from multiprocessing import Process
import time
import os
def task():
    print(f'子进程开始了:{os.getpid()}')
    time.sleep(50)
    print('子进程结束')

if __name__ == '__main__':
    p1 = Process(target=task)
    p1.start()
    print(f'主进程开始了:{os.getpid()}')
# 主进程是子进程的发起者,按理说,主进程不会管子进程是否结束,对于结束来说,两个进程是没有任何关系的.
# 但是通过代码发现: 主进程并没有结束,实际上主进程要等到所有子进程结束之后,才会结束
# 所以此时的主进程就称之为: 僵尸进程
# 主进程此时的内存中只包含: 主进程的pid,以及子进程的开启时间,结束时间,至于主进程的代码以及文件,数据库等等全部消失
# 因为主进程要进行收尸环节:
# 利用waitepid()方法,对所有的结束的子进程进行回收

# 孤儿进程: 此时如果主进程由于各种原因,提前消失,它下面的所有子进程都称为孤儿进程
# 谁给孤儿进程收尸?  一段时间之后,init就会对孤儿进程进行回收

# 孤儿进程无害,如果僵尸进程挂了,init会对孤儿进程进行回收
# 僵尸进程是有害的,假如僵尸进程无限的开启子进程,递归的开启,子进程越来越多,僵尸进程还有没有结束,都不会回收,导致进程越来越多,占用内存

六.守护进程

• 守护进程会在主进程代码执行结束后就终止
• 守护进程内无法再开启子进程

# 子进程对父进程可以进行守护
from multiprocessing import Process
import time
import os
def task():
    print(f'子进程开始了:{os.getpid()}')
    time.sleep(50)
    print('子进程结束')

if __name__ == '__main__':
    p1 = Process(target=task)
    p1.daemon = True  # 将p1子进程设置成守护进程,守护主进程
    # 只要主进程结束,子进程无论执行到哪,都会马上结束
    # 一定要在start之前
    p1.start()
    print(f'主进程开始了:{os.getpid()}')