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("=================================")
  1. 进程对象属性
    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()
  1. 自定义进程类 (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()