4、并发编程之✈✈✈多进程

1、父子进程

2、僵尸进程与孤儿进程

3、守护进程

4、互斥锁（同步锁）

5、生产者消费模型

1、👨‍👦👨‍👦👨‍👦父子进程👨‍👦👨‍👦👨‍👦

  class Myprocess(Process):       #创建一个继承Process的类
      def run(self):
          task('a')               #设置需要启动的进程

  if __name__ == '__main__':
      w = Myprocess()
      w.start()
      w.join()
      print('这是主进程！')


  ##进程对象常用属性
  if __name__ == '__main__':
     p = Process(target=task,args=('a',),name='process-1')    #name属性可以设置进程的名称
     p.start()
     p.join()             # 让父进程等待子进程结束，父进程让出了CPU执行权
     print(p.name)        # 进程名称
     print(p.pid)         # 获取这个进程的id
     p.terminate()        # 结束子进程
     print(p.is_alive())  # 进程是否还存活

     # p这个进程的父进程是当前运行的这个进程
     import os
     print(os.getpid())   # 当前自己进程的id
     print(os.getppid())  # 父进程的id


  #父进程与子进程执行的先后顺序
        父进程一定先执行
        一旦启动子进程，后续的代码就并发，没有先后顺序
        如果父进程需要等待子进程结束后才能执行

1、🥁🥁🥁僵尸进程和孤儿进程👶👶👶

💀💀僵尸进程💀💀

  僵尸进程：
        是linux操作系统中一种特殊的数据结构
        在linux系统中所有的子进程在死后都会进入僵尸进程的状态
        状态信息保留: 给父进程查看用，父进程定期回收僵尸进程的子进程
                    比如pid（任务编号）
        僵尸进程指的是将该进程的重型资源放掉（cpu、内存，打开的文件）但是会保留该进程的状态信息，比如pid

🐱‍🏍孤儿进程🐱‍🏍

  一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。
  孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。

ps:孤儿进程和僵尸进程没有联系，每个子进程‘正常结束’都会变成僵尸进程，但是若是被强行终止，就不存在僵尸进程

☠ 问题危害 ☠

unix提供了一种机制可以保证只要父进程想知道子进程结束时的状态信息， 就可以得到。这种机制就是: 在每个进程退出的时候,内核释放该进程所有的资源,包括打开的文件,占用的内存等。 但是仍然为其保留一定的信息(包括进程号the process ID,退出状态the termination status of the process运行时间the amount of CPU time taken by the process等)。直到父进程通过wait / waitpid来取时才释放。但这样就导致了问题，

如果进程不调用wait / waitpid的话， 那么保留的那段信息就不会释放，其进程号就会一直被占用，但是系统所能使用的进程号是有限的，如果大量的产生僵死进程，将因为没有可用的进程号而导致系统不能产生新的进程. 此即为僵尸进程的危害，应当避免。

孤儿进程是没有父进程的进程，孤儿进程这个重任就落到了init进程身上 ，每当出现一个孤儿进程的时候，内核就把孤 儿进程的父进程设置为init，而init进程会循环地wait()它的已经退出的子进程，因此孤儿进程并不会有什么危害。

任何一个子进程(init除外)在exit()之后，并非马上就消失掉，而是留下一个称为僵尸进程(Zombie)的数据结构，等待父进程处理。这是每个 子进程在结束时都要经过的阶段。如果子进程在exit()之后，父进程没有来得及处理，这时用ps命令就能看到子进程的状态是“Z”。如果父进程能及时 处理，可能用ps命令就来不及看到子进程的僵尸状态，但这并不等于子进程不经过僵尸状态。 如果父进程在子进程结束之前退出，则子进程将由init接管。init将会以父进程的身份对僵尸状态的子进程进行处理。

ps 解决方法:✔✔僵死进程并不是问题的根源，罪魁祸首是产生出大量僵死进程的那个父进程。因此，当我们寻求如何消灭系统中大量的僵死进程时，答案就是把产生大 量僵死进程的那个元凶枪毙掉（也就是通过kill发送SIGTERM或者SIGKILL信号啦）。枪毙了元凶进程之后，它产生的僵死进程就变成了孤儿进 程，这些孤儿进程会被init进程接管，init进程会wait()这些孤儿进程，释放它们占用的系统进程表中的资源

windows和linux系统查看进程和杀掉进程的命令

僵尸进程解决办法

  #1）通过信号机制
        子进程退出时向父进程发送SIGCHILD信号，父进程处理SIGCHILD信号。在信号处理函数中调用wait进行处理僵尸进程
  #2）fork两次
        原理是将子进程成为孤儿进程，从而其的父进程变为init进程，通过init进程可以处理僵尸进程

3、🤖🤖守护进程（了解即可）🤖🤖

  主进程创建守护进程
  其一：守护进程会在主进程代码执行结束后就终止
  其二：守护进程内无法再开启子进程,否则抛出异常：AssertionError: daemonic processes are not allowed to have children
  注意：进程之间是互相独立的，主进程代码运行结束，守护进程随即终止
  from multiprocessing import Process
  import os,time
  def task():
      print('进程%s 开启'%os.getpid())  # 可以看到
      time.sleep(10)
      print('进程%s结束'%os.getpid())  # 看不到 在time.sleep的时候主进程代码结束

  if __name__ == '__main__':
      p = Process(target=task)
      p.daemon = True        # 调用守护进程
      p.start()
      print('主 :%s' %os.getpid())    # 主进程代码结束

4、🔒🔒互斥锁(同步锁)🔒🔒

  #进程之间数据不共享,但是共享同一套文件系统,所以访问同一个文件,或同一个打印终端,是没有问题的,
  #而共享带来的是竞争，竞争带来的结果就是错乱，如何控制，就是加锁处理

part1：多个进程共享同一打印终端

  #并发运行,效率高,但竞争同一打印终端,带来了打印错乱
  from multiprocessing import Process
  import os,time
  def work():
      print('%s is running' %os.getpid())
      time.sleep(2)
      print('%s is done' %os.getpid())

  if __name__ == '__main__':
      for i in range(3):
          p=Process(target=work)
          p.start()

  #加锁: 由并发变成了串行,牺牲了运行效率,但避免了竞争
  from multiprocessing import Process,Lock
  import os,time
  def work(lock):
      lock.acquire()
      print('%s is running' %os.getpid())
      time.sleep(2)
      print('%s is done' %os.getpid())
      lock.release()
  if __name__ == '__main__':
      lock=Lock()
      for i in range(3):
          p=Process(target=work,args=(lock,))
          p.start()

part2：多个进程共享同一文件

文件当数据库，模拟抢票

  #并发运行，效率高，但竞争写同一文件，数据写入错乱
  #文件db的内容为：{"count":1}
  #注意一定要用双引号，不然json无法识别
  from multiprocessing import Process,Lock
  import time,json,random
  def search():
      dic=json.load(open('db.txt'))
      print('\033[43m剩余票数%s\033[0m' %dic['count'])

  def get():
      dic=json.load(open('db.txt'))
      time.sleep(0.1) #模拟读数据的网络延迟
      if dic['count'] >0:
          dic['count']-=1
          time.sleep(0.2) #模拟写数据的网络延迟
          json.dump(dic,open('db.txt','w'))
          print('\033[43m购票成功\033[0m')

  def task(lock):
      search()
      get()
  if __name__ == '__main__':
      lock=Lock()
      for i in range(100): #模拟并发100个客户端抢票
          p=Process(target=task,args=(lock,))
          p.start()
 #加锁：购票行为由并发变成了串行，牺牲了运行效率，但保证了数据安全 
  #文件db的内容为：{"count":1}
  #注意一定要用双引号，不然json无法识别
  from multiprocessing import Process,Lock
  import time,json,random
  def search():
      dic=json.load(open('db.txt'))
      print('\033[43m剩余票数%s\033[0m' %dic['count'])

  def get():
      dic=json.load(open('db.txt'))
      time.sleep(0.1) #模拟读数据的网络延迟
      if dic['count'] >0:
          dic['count']-=1
          time.sleep(0.2) #模拟写数据的网络延迟
          json.dump(dic,open('db.txt','w'))
          print('\033[43m购票成功\033[0m')

  def task(lock):
      search()
      lock.acquire()
      get()
      lock.release()
  if __name__ == '__main__':
      lock=Lock()
      for i in range(100): #模拟并发100个客户端抢票
          p=Process(target=task,args=(lock,))
          p.start()

小结

  #加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改，没错，速度是慢了，但牺牲了速度却保证了数据安全。
  虽然可以用文件共享数据实现进程间通信，但问题是：
  1.效率低（共享数据基于文件，而文件是硬盘上的数据）
  2.需要自己加锁处理
  #因此我们最好找寻一种解决方案能够兼顾：1、效率高（多个进程共享一块内存的数据）2、帮我们处理好锁问题。这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制：队列和管道。
  1 队列和管道都是将数据存放于内存中
  2 队列又是基于（管道+锁）实现的，可以让我们从复杂的锁问题中解脱出来，
  我们应该尽量避免使用共享数据，尽可能使用消息传递和队列，避免处理复杂的同步和锁问题，而且在进程数目增多时，往往可以获得更好的可获展性。

👇👇👇推荐使用（队列）👇👇👇

进程彼此之间互相隔离，要实现进程间通信（IPC），multiprocessing模块支持两种形式：队列和管道，这两种方式都是使用消息传递的

1、创建队列的类（底层就是以管道和锁定的方式实现）：

  #1 Queue([maxsize]):创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。

2、参数介绍：

  #1 maxsize是队列中允许最大项数，省略则无大小限制。  

3、方法介绍

  q.put方法用以插入数据到队列中，put方法还有两个可选参数：blocked和timeout。如果blocked为True（默认值），
  并且timeout为正值，该方法会阻塞timeout指定的时间，直到该队列有剩余的空间。如果超时，会抛出Queue.Full异常。如果blocked为False，但该Queue已满，会立即抛出Queue.Full异常。

  q.get方法可以从队列读取并且删除一个元素。同样，get方法有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，那么在等待时间内没有取到任何元素，会抛出Queue.Empty异常。
  如果blocked为False，有两种情况存在，如果Queue有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出Queue.Empty异常.
  q.get_nowait():同q.get(False)
  q.put_nowait():同q.put(False)

  q.empty():调用此方法时q为空则返回True，该结果不可靠，比如在返回True的过程中，如果队列中又加入了项目。
  q.full()：调用此方法时q已满则返回True，该结果不可靠，比如在返回True的过程中，如果队列中的项目被取走。
  q.qsize():返回队列中目前项目的正确数量，结果也不可靠，理由同q.empty()和q.full()一样

其他方法（了解

  1 q.cancel_join_thread():不会在进程退出时自动连接后台线程。可以防止join_thread()方法阻塞
  2 q.close():关闭队列，防止队列中加入更多数据。调用此方法，后台线程将继续写入那些已经入队列但尚未写入的数据，
  但将在此方法完成时马上关闭。如果q被垃圾收集，将调用此方法。关闭队列不会在队列使用者中产生任何类型的数据结束信号或异常。
  例如，如果某个使用者正在被阻塞在get()操作上，关闭生产者中的队列不会导致get()方法返回错误。
  3 q.join_thread()：连接队列的后台线程。此方法用于在调用q.close()方法之后，等待所有队列项被消耗。默认情况下，
  此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread方法可以禁止这种行为

应用

  multiprocessing模块支持进程间通信的两种主要形式:管道和队列
  都是基于消息传递实现的,但是队列接口
  from multiprocessing import Process,Queue
  import time
  q=Queue(3)
  #put ,get ,put_nowait,get_nowait,full,empty
  q.put(3)
  q.put(3)
  q.put(3)
  print(q.full()) #满了

  print(q.get())
  print(q.get())
  print(q.get())
  print(q.empty()) #空了

5、👨‍🌾👨‍🌾生产者消费模型👨‍🌾👨‍🌾

  生产者消费者模型:
      该模型有两种角色，一种是生产者，另外一种是消费者
  生产者负责产生数据，消费者负责取走数据进行处理

  生产者与消费者通过队列通信

  优点: 解耦合，平衡了生产者的生产力与消费者的处理能力

🐳案例一、🐳

  from multiprocessing import Process,Queue
  import time
  import random
  def producer(q,name,food):
      for i in range(3):
          res = '%s%s' %(food,i)
          time.sleep(random.randint(1,3))
          q.put(res)
          print('%s 生产力 %s' %(name,res))


  def cconsumer(q,name):
      while True:
          res = q.get()
          if res is None:
              break
          time.sleep(random.randint(1,3))
          print('%s 吃了 %s' %(name,res))

  if __name__ == '__main__':
      q = Queue

      p1 = Process(target=producer,args=(q,'厨师','包子'))
      p2 = Process(target=producer,args=(q,'厨师','烧卖'))
      p3 = Process(target=producer,args=(q,'厨师','馒头'))

      c1 = Process(target=cconsumer,args=(q,'lxx'))
      c2 = Process(target=cconsumer,args=(q,'hxx'))

      p1.start()
      p2.start()
      p3.start()
      c1.start()
      c2.start()

      p1.join()
      p2.join()
      p3.join()
      q.put(None)
      q.put(None)
      print('主')

🐳案例二、🐳利用守护进程机制

  from multiprocessing import Process,JoinableQueue
  import time
  import random

  def producer(q,name,food):
      for i in range(3):
          res = "%s%s" %(food,i)
          time.sleep(random.randint(1,3))
          q.put(res)
          print("%s 生产了 %s" %(name,res))
      q.join()

  def consumer(q,name):
      while True:
          res = q.get()
          if res is None:
              break
          time.sleep(random.randint(1,3))
          print("%s 吃了 %s" %(name,res))

          q.task_done()

  if __name__ == '__main__':
      q = JoinableQueue()
      p1 = Process(target=producer,args=(q,'厨师','包子'))
      p2 = Process(target=producer,args=(q,'厨师','烧卖'))
      p3 = Process(target=producer,args=(q,'厨师','馒头'))

      c1 = Process(target=consumer,args=(q,'lxx'))
      c2 = Process(target=consumer,args=(q,'hxx'))
      c1.daemon=True
      c2.daemon=True

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