multiprocessing 模块使用--POLL--管道

multiprocessing 模块使用

1. 创建流程
   *将需要子进程处理的时间封装为函数
   *通过process类创建进程对象，关联函数
   *可以通过进程的对象对进程进行属性设置
   *通过start启动进程
   *通过join回收进程

2. 接口使用
   【1】Process(target = 函数名字,args = (),kwargs = {})
   功能：创建进程对象
   参数：target绑定要执行的目标函数
   args元组 给target函数位置传参
   kwargs 字典 给target函数关键字传参

   from multiprocessing import Process
   from time import sleep
   
   def worker(sec,name):
       for i in range(3):
           sleep(sec)
           print("I'm %s"%name)
           print("I'm working...")
   
   # p = Process(target = worker,args = (2,"Baron"))
   # p = Process(target = worker,kwargs = {"name":"Baron","sec":2})
   p = Process(target = worker,args = (2,),kwargs = {"name":"Baron"})
   p.start()
   p.join()
   

   【2】p.start()
   功能：启动进程
   * 此时进程产生，将p绑定函数作为新进程的执行内容
   【3】p.join([timeout])
   功能：阻塞等待回收进程
   参数：超时时间
   *multiprocessing创建进程同样是复制父进程的空间代码段，父子进程运行互不影响
   *子进程只执行target绑定函数，其余均父进程执行
   *Process创建进程中，往往父进程只用来创建和回收进程，具体事件由子进程完成
   *multiprosessing创建的子进程中不能使用标准输入

import multiprocessing as mp
from time import sleep

#编写进程函数
def fun():
    sleep(5)
    print("子进程执行事件")

# 创建进程对象
p = mp.Process(target=fun)


# 启动进程
p.start()
sleep(1)
print("==========rrrrr========")
# 回收进程
p.join()
print("=================================")

3. 进程对象属性
   p.name 进程名称
   p.pid 进程pid号
   p.is_alive() 进程是否在生命周期
   p.daemon 设置父子进程的退出关系
   *将该属性设置为True则父进程退出，其子进程也会退出
   *要求必须在start()前设置
   *不会和jion一起使用

from multiprocessing import Process
from time import sleep,ctime

def fun():
    for i in range(3):
        sleep(2)
        print(ctime())

p = Process(target=fun,name = "定义名字")
p.daemon = True#父进程结束之后，子进程也会结束

p.start()

print("Name",p.name)
print("pid",p.pid)
print("alive",p.is_alive())
# sleep(10)

# p.join()

4. 自定义进程类 (Process)
   编写流程：
   编写子的__init__函数添加属性，super重新加载父类__init__方法
   重写Process中run方法
   使用
   使用自定义类实例化对象
   通过对象调用start()创建进程，自动运行run
   通过join回收进程

from multiprocessing import Process
import time

# 自定义进程类
class ClockProcess(Process):
    def __init__(self,value):
        self.value = value
        super().__init__()

    # 重写方法


    def run(self):
        for i in range(5):
            print("The time is %s"%time.ctime())
            time.sleep(self.value)
# 创建进程对象
p = ClockProcess(2)
p.start()
# print("3333")
p.join()

进程池技术 Pool

1. 必要性
   *进程的创建和销毁过程消耗的计算机资源较多
   *当任务量众多，每个任务又比较小的时候，需要频繁创建销毁进程，对计算机压力较大
   *进程池技术很好的解决了上述问题
2. 原理：创建一定数量的进程来处理事件，事件处理完进程不退出而是继续处理其他事件，
   直到所有事件都处理完毕再一同销毁，增加进程的复用性，降低资源消耗。
3. 进程池实现
   from multiprocessing import Pool
   Pool(Processes)
   功能：创建进程池对象
   参数：指定创建进程数量，默认根据系统自动判定
   pool.apply_async(func,args,kwds):
   功能：将进程事件加入进程池
   参数：func进程事件函数
   args给进程事件元组传参
   kwds给进程事件字典传参
   pool.close()
   功能：关闭进程池
   pool.join()
   功能：回收进程池

from multiprocessing import Pool
from time import sleep

# 进程池事件函数
def worker(msg):
    sleep(2)
    print(msg)

# 创建进程池
pool = Pool()
for i in range(10):
    msg = "hello %s"%i
    pool.apply_async(func = worker,args=(msg,))
# 关闭进程池
pool.close()
# 回收进程池
pool.join()

进程间通信（IPC）

1. 必要性：进程空间独立，资源不共享，此时在需要进程间数据传输时， 需要一定的方法手段，
2. 进程间通讯方法：
   管道Pipe 消息队列 共享内存 信号 信号量 套接字
   消息队列 共享内存 信号 信号量 套接字
3. 管道通信：
   通信原理：在内存中开辟管道空间，生成管道对象多个进程使用同一管道进行读写操作
   实现方法
   from multiprocessing import Pipe
   fd1,fd2 = Pipe(duplex = True)
   功能：创建管道
   参数：默认表示双向管道，False表示单向管道
   返回值：表示管道两端读写对象。
   如果是双向管道均可读写
   单向管道fd1只读，fd2只写
   fd.recv()
   功能：从管道读取内容
   返回值：读取到的内容
   fd.send()
   功能：向管道写入内容
   参数：要写入的数据

from multiprocessing import Pipe,Process
import time,os


fd1,fd2 = Pipe()

def fun(name):
    time.sleep(3)
    # 写入管道
    fd1.send({name:os.getpid()})


jobs = []
for i in range(5):
    p = Process(target=fun,args=(i,))
    jobs.append(p)
    p.start()

for i in range(5):
    # 读取
    data = fd2.recv()
    print(data)

for i in jobs:
    i.join()