day34进程相关

进程
1 什么是进程
    进程指的是一个正在进行/运行的程序,进程是用来描述程序执行过程的虚拟概念
    进程vs程序
    程序:一堆代码
    进程:程序的执行的过程
    进程的概念起源于操作系统,进程是操作系统最核心的概念,操作系统其它所有的概念都是围绕进程来
    操作系统理论:
            操作系统是一个协调\管理\控制计算机硬件资源与应用软件资源的一段控制程序
            有两大功能:
                1. 将复杂的硬件操作封装成简单的接口给应用程序或者用户去使用
                2. 将多个进程对硬件的竞争变得有序
    操作系统发展史
        并发: 多个任务看起来是同时运行的
        串行:一个任务完完整整地运行完毕,才能运行下一个任务
        多道技术:(复用=>共享/共用)
            1. 空间上的复用:多个任务复用内存空间
            2. 时间上的复用:多个任务复用cpu的时间
                1. 一个任务占用cpu时间过长会被操作系统强行剥夺走cpu的执行权限:比起串行执行反而会降低效率
                2. 一个任务遇到io操作也会被操作系统强行剥夺走cpu的执行权限:比起串行执行可以提升效率
2 为何用进程
   实现并发
3 如何用进程
 开启子进程的方式一:  #调研系统类地点方式
  from multiprocessing import Process
  import time
  def task(name):
   print('%s is running' %name)
   time.sleep(3)
   print('%s is done' %name)
  # 在windows系统上,开启子进程的操作必须放到if __name__ == '__main__'的子代码中
  if __name__ == '__main__':
   p=Process(target=task,args=('egon',))   #Process(target=task,kwargs={'name':'egon'})
   p.start()   # 只是向操作系统发送了一个开启子进程的信号
   p.join() # join:让主进程在原地等待,等待子进程运行完毕,不会影响子进程的执行(****) 
   print('主') # join:让主进程等待子进程运行完毕,即主进程在原地阻塞,而不影响子进程的运行
      
 开启子进程的方式二:   #自定义类的方式
  from multiprocessing import Process
  import time
  class Myprocess(Process):
   def __init__(self,name):
    super().__init__()
    self.name=name
   def run(self):
    print('%s is running' %self.name)
    time.sleep(3)
    print('%s is done' %self.name)
  # 在windows系统上,开启子进程的操作必须放到if __name__ == '__main__'的子代码中
  if __name__ == '__main__':
   p=Myprocess('egon')          #p为进程对象
   p.start() # 只是向操作系统发送
4 进程相关其它操作
 1. 进程pid:每一个进程在操作系统内都有一个唯一的id号,称之为pid
 2.from multiprocessing import Process,current_process 
      current_process()  #当前进程的pid,相当于os.getpid().其中os.getppid():查看父进程的pid
 3. 进程对象其他相关的属性或方法
  p.terminate()  结束进程p
  p.is_alive()   查看进程p是否结束
 4.僵尸进程和孤儿进程:僵尸进程指死掉的进程. 孤儿进程:父进程死掉,子进程变成孤儿进程,此时父进程为:INIT
 5.守护进程: 本质就是一个"子进程",该"子进程"的生命周期<=被守护进程的生命周期
  p.daemon=True  #设置进程p 为守护进程
 6.互斥锁  :from multiprocessing import Process,Lock
  mutex = Lock()    #创建锁对象
  for i in range(10):
  p=Process(target=task,args=('路人%s' %i,mutex))  #创建进程时把互斥锁传进之进程中
  p.start()
  def task(name,mutex):
   search(name) #并发
   mutex.acquire()  #开始上锁
   get(name) #变成串行
   mutex.release()  #解锁
  join VS 互斥锁
        join:是将代码整体串行
        互斥锁:是将代码中的关于修改共享数据的 那一小部分代码变成串行,牺牲了效率保证数据安全
5.进程间通信(ICP机制)
 #队列=管道+锁  from multiprocessing import Queue
 q=Queue() #创建队列
 q.put(['first',]) #向队列中传入一个元素
 q.get()   #向队列中取出一个元素
 q=Queue(3) #队列中最大元素的个数
 q.put(['first',],block=True,timeout=3)  #队列已满时等待3秒,如果block=False,若队列已满直接报错
 q.get(block=True,timeout=3)  #队列为空时等待3秒,如果block=False,若队列为空直接报错
 q.put_nowait(1) #等效于q.put(1,block=False)
 q.get_nowait()) #等效于q.get(block=false)
6.生产者消费者模型(******)
 1. 什么是生产者消费者模型
  生产者:代指生产数据的任务
  消费者:代指处理数据的任务
  该模型的工作方式:
   生产生产数据传递消费者处理
   实现方式:生产者---->队列<------消费者
 2. 为何要用
  当程序中出现明细的两类任务,一类负责生产数据,一类负责处理数据
  就可以引入生产者消费者模型来实现生产者与消费者的解耦合,平衡生产能力与消费能力,从提升效率
 3. 如何用
  import time,random
  from multiprocessing import Process,Queue
  def producer(name,food,q):
   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 consumer(name,q):
   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=('小Egon','泔水',q))
   p2=Process(target=producer,args=('中Egon','屎包子',q))
   p3=Process(target=producer,args=('大Egon','腰子汤',q))
   # 消费者们
   c1=Process(target=consumer,args=('刘清正',q))
   c2=Process(target=consumer,args=('吴三江',q))
   p1.start()
   p2.start()
   p3.start()
   c1.start()
   c2.start()
   p1.join()
   p2.join()
   p3.join()
   q.put(None)
   q.put(None)
   print('主')
 4.补充了解第二种实现方式:
  import time,random
  from multiprocessing import Process,JoinableQueue  #可调用队列
  def producer(name,food,q):
   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 consumer(name,q):
   while True:
    res=q.get()
    time.sleep(random.randint(1,3)) #模拟处理数据的时间
    print('吃货[%s]吃了<%s>' %(name,res))
    q.task_done()
  if __name__ == '__main__':
   q=JoinableQueue()  #相当与可调用的q=Queue()
   # 生产者们
   p1=Process(target=producer,args=('小Egon','泔水',q))
   p2=Process(target=producer,args=('中Egon','屎包子',q))
   p3=Process(target=producer,args=('大Egon','腰子汤',q))
   # 消费者们
   c1=Process(target=consumer,args=('刘清正',q))
   c2=Process(target=consumer,args=('吴三江',q))
   c1.daemon=True  #设定为守护进程
   c2.daemon=True  #设定为守护进程
   #运行进程
   p1.start()
   p2.start()
   p3.start()
   c1.start()
   c2.start()
   #等待生产者进程结束才继续主进程
   p1.join()
   p2.join()
   p3.join()
   q.join()  # 主进程等q结束,即q内数据被取干净了
   print('主')