python 进程

• 1.并发和并行：
  • 并发：当有多个线程在操作时,如果系统只有一个CPU,则它根本不可能真正同时进行一个以上的线程，它只能把CPU运行时间划分成若干个时间段,
    • 再将时间 段分配给各个线程执行，在一个时间段的线程代码运行时，其它线程处于挂起状。.这种方式我们称之为并发(Concurrent)。
  • 并行：当系统有一个以上CPU时,则线程的操作有可能非并发。当一个CPU执行一个线程时，另一个CPU可以执行另一个线程，
    • 两个线程互不抢占CPU资源，可以同时进行，这种方式我们称之为并行(Parallel)。
    • 多任务在程序中中的实现进程和线程
• 2.os.fork 创建进程 window 下不支持
  • import os
  • pid=os.fork()  #返回值0为子进程，>0父进程，-1创建失败
  • if pid==0:
    • print("子进程%s,父进程%s"%(os.getpid(),os.getooid()))
  • elif pid>0;
    • print("父进程%s,父进程的父进程%s,子进程"%s(os.getpid,os.getppid,pid))
  • else:
    • print("创建进程失败")
  • os.getpid() 获取当前进程号
  • os.getppid() 获取当前进程的父进程号
  • 进程之间数据不共享
  • 原理：
    • fork函数生成子进程是父进程的镜像，但是有各自的地址空间，两进程执行独立，执行顺序无法预测
    • 子进程获取父进程代码和数据段，共享库，堆和栈的拷贝，变量的地址一样，在某一进程中修改相同变量的值，在另一进程中的相同变量的值不变
• 3.创建跨平台的进程 multiprocessing   支持window
  • 1.from multiprocessing import Process
    • p=Process(target=进程任务函数名 args=(进程任务函数的参数元组形式) name=进程别名)
    • p.start()  启动进程
    • p.join() 让主进程让步（等待子进程结束后再继续往下运行）可以指定参数时间表示主进程等待子进程秒数
    • p.name() 查看进程名
    • p.is_alive() 判断子进程是否执行完毕
  • 2.自定义Process子类
    • 1.创建子类继承Process 2.重写run方法（当使用Procss创建子进程未指定target参数，则进行run方法）
      • from multiprocessing import Process
      • class MyProcess(Process):
      • def run(self):
        • print("子进程名",self.name)
      • if __name__=="__main__":   #window 下必须有
        • p=MyProcess()
        • p.name="子进程1"
        • p.start()  #进程启动
        • p.join()   #让主进程让步（子进程执行完毕后才执行后面的内容）
        • print("主进程执行完毕")
• 4.使用进程池创建进程
  • 1.初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；
    • 但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程来执行。
  • 2.阻塞式，添加一个执行一个，执行完毕才返回，然后接着下一个
  • 3.非阻塞式，全部添加到队列中，立刻返回，当执行完毕会有回调，回调含结果
  • 4.举例
    • import multiprocessing import Pool
    • import time
    • def dowload(name): #进程任务函数
      • print("开始下载",name)
      • time.sleep(0.5) #休息0.5秒
      • print("下载完成",name)
      • return name   #返回值将作为参数传入回调函数callback
    • def call_back(filename): #非堵塞式执行完毕会有回调
      • print("回调",filename)
    • if __name__=="__main__":
      • pool=Pool(3) #创建进程池 最大进程3
      • image=["1.jpeg","2.jpeg","3.jpeg","4.jpeg"]
      • for i in image:
        • obj=pool.apply_async(dowload,args=(i,),callback=call_back) #非堵塞式 apply_async(进程任务函数名,args=(进程任务函数参数(元组格式))，callback=回调函数名（回调函数可有可无）)
        • print(obj)  #非堵塞式 立刻返回对象
      • pool.close() #关闭进程池，使之不再接受新任务，非堵塞式这句话必须有
      • pool.join() #主进程让步,进程池中，主进程任务结束，进程池中任务即使没有也结束，所有加这句话保证子进程的执行,堵塞式不需要
      • print("主进程 全部下载完毕")
      • #堵塞式
      • for i in image():
        • obj=pool.apply(dowload,args=(i,))  # apply(进程任务函数名,args=(进程任务函数参数(元组格式))) 无回调函数     添加一个进程执行一个
        • print(obj)  #等待进程任务函数完毕，才返回且返回的是任务函数的返回值，然后执行下一个进程
      • print("主进程 全部下载完毕")
• 5.使用Queue 实现进程之间通信（进程间默认是不可用通信的）
  • 1.Queue参数
    • 1.初始化Queue()对象时（例如：q=Queue()），若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接受的消息数量没有上限（直到内存的耗尽）；
    • 2.Queue.qsize()：返回当前队列包含的消息数量；
    • 3.Queue.empty()：如果队列为空，返回True，反之False ；
    • 4.Queue.full()：如果队列满了，返回True,反之False；
    • 5.Queue.get([block[, timeout]])：获取队列中的一条消息，然后将其从列队中移除，block默认值为True；
      • 1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果为空，此时程序将被阻塞（停在读取状态），直到从消息列队读到消息为止，如果设置了timeout，则会等待timeout秒，若还没读取到任何消息，则抛出"Queue.Empty"异常；
      • 2）如果block值为False，消息列队如果为空，则会立刻抛出"Queue.Empty"异常；
    • 6.Queue.get_nowait()：相当Queue.get(False)；
    • 7.Queue.put(item,[block[, timeout]])：将item消息写入队列，block默认值为True；
      • 1）如果block使用默认值，且没有设置timeout（单位秒），消息列队如果已经没有空间可写入，此时程序将被阻塞（停在写入状态），直到从消息列队腾出空间为止，如果设置了timeout，则会等待timeout秒，若还没空间，则抛出"Queue.Full"异常；
      • 2）如果block值为False，消息列队如果没有空间可写入，则会立刻抛出"Queue.Full"异常；
    • 8.Queue.put_nowait(item)：相当Queue.put(item, False)
  • 2.使用Queue实现使用Process创建的进程之间的通信
    • from multiprocessing import Queue, Process  #导入模块
    • import time
    • def put(qu): #往队列李添加内容的进程任务函数
      • books = ["西游记", "三国演义", "红楼梦", "水浒传"]
      • if qu.empty(): #队列为空
        • for i in books:
          • qu.put(i)  #往队列中循环添加消息
          • print("图书馆有", i)
          • time.sleep(0.5)  #每次休息0.5秒
    • def get(qu): #从队列中取消息的进程任务函数
      • try:
        • while True:
        • book = qu.get(timeout=2) #循环取消息  如果超过两秒取不到报错
        • print("借到", book)
      • except:
        • print("没借到")   #报错 结束进程
    • if __name__ == "__main__":
      • qu = Queue(5)  #创建队列对象，最大队列消息条数为5
      • p1 = Process(target=put, args=(qu,), name="图书馆") #创建队列添加内容的进程
      • p2 = Process(target=get, args=(qu,), name="借书人") #创建从队列取消息的进程
      • p1.start()
      • p2.start()
      • p1.join()
      • p2.join()
      • print("主进程 完毕")
  • 3.使用Manager()中的Queue实现使用进程池创建的进程之间的通信
    • from multiprocessing import Manager,Pool #导入模块
    • def put(qu): #往队列李添加内容的进程任务函数
      • books = ["西游记", "三国演义", "红楼梦", "水浒传"]
      • if qu.empty(): #队列为空
      • for i in books:
      • qu.put(i)  #往队列中循环添加消息
      • print("图书馆有", i)
      • time.sleep(0.5)  #每次休息0.5秒
    • def get(qu): #从队列中取消息的进程任务函数
      • try:
        • while True:
          • book = qu.get(timeout=2) #循环取消息  如果超过两秒取不到报错
          • print("借到", book)
      • except:
      • print("没借到")   #报错 结束进程
    • if __name__ == "__main__":
      • qu = Manager().Queue(5)  #创建队列对象，最大队列消息条数为5
      • pool=Pool(3)
      • pool.apply_async(put,args=(qu,))
      • pool.apply_async(put,args=(qu,))
      • pool.close()
      • pool.join()
      • print("主进程 完毕")