python-day32(进程池,管道,数据共享)

一. 管道

　　进程间通信(IPC)  管道(不推荐使用),会导致数据不安全的情况出现,

　　conn1,conn2 = Pipe 表示管道两端的连接对象,强调一点: 必须在产生Process对象之前产生管道

　　主要方法:

　　　　conn1.recv(): 接收从conn2.send(obj)对象,如果没有消息可接收,recv方法会一直阻塞,

　　　　　　如果连接的另一端已经关闭,namerecv方法会抛出EOFError

　　　　conn1.send(obj): 通过连接发送对象,obj是与序列化兼容的任意对象

　　其他方法:

　　　　conn1.close(): 关闭连接, 如果conn1被垃圾回收,将自动调用次方法

from multiprocessing import Process, Pipe

def f(conn):
    conn.send("Hello 妹妹") #子进程发送了消息
    conn.close()

if __name__ == '__main__':
    parent_conn, child_conn = Pipe() #建立管道，拿到管道的两端，双工通信方式，两端都可以收发消息
    p = Process(target=f, args=(child_conn,)) #将管道的一段给子进程
    p.start() #开启子进程
    print(parent_conn.recv()) #主进程接受了消息
    p.join()

二. 数据共享

　　Manager:进程间数据是独立的,可以借助于队列或者管道实现通信,二者都是基于消息传递的

　　　　　　虽然进程间数据独立,但可以通过Manager实现数据共享

　　多进程共同去处理共享数据的时候,就和我们多进程同时去操作一个文件中的数据是一样的,

　　不加锁就会出现错误的结果,进程不安全的,所以也需要加锁

from multiprocessing import Manager,Process,Lock
def work(d,lock):
    with lock: #不加锁而操作共享的数据,肯定会出现数据错乱
        d['count']-=1

if __name__ == '__main__':
    lock=Lock()
    with Manager() as m:
        dic=m.dict({'count':100})
        p_l=[]
        for i in range(100):
            p=Process(target=work,args=(dic,lock))
            p_l.append(p)
            p.start()
        for p in p_l:
            p.join()
        print(dic)

 (进程间的通信: 管道,队列,数据共享)

三. 进程池 (重点)

　　创建进程池的类: 如果指定numprocess参数为3,则进程池会从无到有创建三个进程,然后

　　自始至终使用这三个进程去执行所有任务,不会开启其他进程,提高操作系统效率,减少空间的占用

　　创建进程池 p = Pool(4) #四个进程 如果省略,将默认使用 cpu_count() 的值

　　p.apply()  同步提交任务,直接可以收到返回值

import os,time
from multiprocessing import Pool

def work(n):
    print('%s run' %os.getpid())
    time.sleep(1)
    return n**2

if __name__ == '__main__':
    p=Pool(3) #进程池中从无到有创建三个进程,以后一直是这三个进程在执行任务
    res_l=[]
    for i in range(10):
        res=p.apply(work,args=(i,)) # 同步调用，直到本次任务执行完毕拿到res，等待任务work执行的过程中可能有阻塞也可能没有阻塞
                                    # 但不管该任务是否存在阻塞，同步调用都会在原地等着
        res_l.append(res)
    print(res_l)

　　p.apply_async() 异步提交任务: res.get() 阻塞效果

import os
import time
import random
from multiprocessing import Pool

def work(n):
    print('%s run' %os.getpid())
    time.sleep(random.random())
    return n**2

if __name__ == '__main__':
    p=Pool(3) #进程池中从无到有创建三个进程,以后一直是这三个进程在执行任务
    res_l=[]
    for i in range(10):
        res=p.apply_async(work,args=(i,)) # 异步运行，根据进程池中有的进程数，每次最多3个子进程在异步执行，并且可以执行不同的任务，传送任意的参数了。
                                          # 返回结果之后，将结果放入列表，归还进程，之后再执行新的任务
                                          # 需要注意的是，进程池中的三个进程不会同时开启或者同时结束
                                          # 而是执行完一个就释放一个进程，这个进程就去接收新的任务。  
        res_l.append(res)

    # 异步apply_async用法：如果使用异步提交的任务，主进程需要使用join，等待进程池内任务都处理完，然后可以用get收集结果
    # 否则，主进程结束，进程池可能还没来得及执行，也就跟着一起结束了
    p.close() #不是关闭进程池，而是结束进程池接收任务，确保没有新任务再提交过来。
    p.join()   #感知进程池中的任务已经执行结束，只有当没有新的任务添加进来的时候，才能感知到任务结束了，所以在join之前必须加上close方法
    for res in res_l:
        print(res.get()) #使用get来获取apply_aync的结果,如果是apply,则没有get方法,因为apply是同步执行,立刻获取结果,也根本无需get

　　　　close join

　　p.map()  异步提交任务,参数是可迭代对象,自带close + join

import time
from multiprocessing import Process,Pool


def func(i):
    num = 0
    for j in range(5):
        num += i


if __name__ == '__main__':
    pool = Pool(4)  #
    p_list = []
    start_time = time.time()
    for i in range(100):
        p = Process(target=func,args=(i,))
        p_list.append(p)
        p.start()
    [pp.join() for pp in p_list]
    end_time = time.time()
    print(end_time - start_time)

    s_time = time.time()
    pool.map(func,range(100))  #map
    e_time = time.time()
    print(e_time - s_time)

 回调函数:callback

import os
from multiprocessing import Pool

def func1(n):
    print('func1>>',os.getpid())
    print('func1')
    return n*n

def func2(nn):
    print('func2>>',os.getpid())
    print('func2')
    print(nn)
    # import time
    # time.sleep(0.5)
if __name__ == '__main__':
    print('主进程：',os.getpid())
    p = Pool(5)
    #args里面的10给了func1，func1的返回值作为回调函数的参数给了callback对应的函数，不能直接给回调函数直接传参数，他只能是你任务函数func1的函数的返回值
    # for i in range(10,20): #如果是多个进程来执行任务，那么当所有子进程将结果给了回调函数之后，回调函数又是在主进程上执行的，那么就会出现打印结果是同步的效果。我们上面func2里面注销的时间模块打开看看
    #     p.apply_async(func1,args=(i,),callback=func2)
    p.apply_async(func1,args=(10,),callback=func2)

    p.close()
    p.join()

#结果
# 主进程： 11852  #发现回调函数是在主进程中完成的，其实如果是在子进程中完成的，那我们直接将代码写在子进程的任务函数func1里面就行了，对不对，这也是为什么称为回调函数的原因。
# func1>> 17332
# func1
# func2>> 11852
# func2
# 100

需要回调函数的场景：进程池中任何一个任务一旦处理完了，就立即告知主进程：我好了额，你可以处理我的结果了。主进程则调用一个函数去处理该结果，该函数即回调函数，这是进程池特有的，普通进程没有这个机制，但是我们也可以通过进程通信来拿到返回值，进程池的这个回调也是进程通信的机制完成的。

我们可以把耗时间（阻塞）的任务放到进程池中，然后指定回调函数（主进程负责执行），这样主进程在执行回调函数时就省去了I/O的过程，直接拿到的是任务的结果

其他方法:
p.close():关闭进程池,防止进一步操作
p.join():等待所有工作进程退出,次方法只能在close()或teminate()之后调用

更多点击