python摸爬滚打之day032 管道 数据共享 进程池

1、进程池

　　当有成千上万个任务需要被执行的时候，有了进程池我们就不必去创建大量的进程. 首先，创建进程需要消耗时间，销毁进程（空间，变量，文件信息等等的内容）也需要消耗时间, 第二即便开启了成千上万的进程，操作系统也不能让他们同时执行，维护一个很大的进程列表的同时，调度的时候，还需要进行频繁切换并且记录每个进程的执行节点, 这样反而会影响程序的效率。

　　创建一个有固定数量的进程池, 执行任务的时候就拿池中的进程来处理任务，等到处理完毕，进程并不关闭，而是将进程再放回进程池中继续等待任务, 可以减少创建进程的开支. 这样不会增加操作系统的调度难度，还节省了开闭进程的时间，也一定程度上能够实现并发效果. 

　　使用进程池来实现并发效果, 减少创建进程的开支, 提高效率.

map()方法: 异步调用进程, map自带join()的功能.

import  time
from multiprocessing import Pool,Process


def func1(i):
    numb = 0
    for j in range(5):
        numb += i


if __name__ == '__main__':

    p_lst = []
    s_time = time.time()
    for i in range(500):
        p = Process(target=func1,args=(i,))
        p.start()
        p_lst.append(p)
    [pp.join() for pp in p_lst]
    e_time = time.time()
    dis_time = e_time - s_time
    print("非进程池",dis_time)    # 9.458896160125732 处理时间

# ---------------------------------------------------------------------------------

    pool = Pool(4)
    ps_time = time.time()
    pool.map(func1, range(100))      # 把可迭代对象的每一个元素都作为参数扔给func1
    pe_time = time.time()
    dis_time = pe_time - ps_time
    print("进程池",dis_time)       # 0.07204794883728027 处理时间

apply()方法: 提供一个同步串行的方法.

import  time
from multiprocessing import Pool,Process


def func1(i):
    numb = 0
    for j in range(5):
        numb += i
    time.sleep(0.5)
    return numb




if __name__ == '__main__':

    pool = Pool(4)

    for i in range(10):
        print(i)
        ret = pool.apply(func1, args=(i,))     # apply提供的是一个同步串行的执行方法. 
                                               # 进程1 执行完任务后, ret 获取到数据, 第二个进程才开始执行任务.
        
        print(ret)

apply_async()方法: 进程池异步调用方法.

　　注意: 在使用进程池异步调用时, 主进程结束时, 所有的子进程也跟着一起结束了(后台全部关闭), 所以主程序必须得先 join() , 等待子进程结束.

　　使用apply_async()异步调用时, 主程序必须使用 join() 方法, 等待进程池内的任务都处理完, 才能用get()获取结果.

　　使用map()异步调用时, 不用写 join() 方法, map()会自动 join().

import  time
from multiprocessing import Pool,Process


def func1(i):
    numb = 0
    for j in range(5):
        numb += i
    time.sleep(1)
    return numb



if __name__ == '__main__':

    pool = Pool(4)
    ret_lst = []
    for i in range(10):         # 相当于发布10个任务, 4个进程都过来拿任务
        print(i)
        res = pool.apply_async(func1,args=(i,))         # 各进程都是异步状态
        ret_lst.append(res)         # 这一步, 是把所有的res的执行对象都先放进列表里(包括那些没有结果的对象,
                                    # 即使后面6个任务都没有执行,但是都是先把执行对象放进列表里)

    pool.close()        # 不是关闭进程池, 而是结束进程池接受任务, 确保没有任务再传过来
    pool.join()         # 感知进程池中的任务已经结束, 只有进程池结束接收任务, 才能感知进程池中的任务结束, 所以必须加 close().

    for res in ret_lst:
        print(res.get())      # 前4个有结果, 用get()方法获取到结果后, 一直阻塞在后六个处,直到结果传进来执行对象中

 2、回调函数

　　回调函数在主进程中被执行的, 子进程执行完相应的代码后, 返回主进程去执行回调函数, 它帮我们省略了主进程自身调用函数的这一步骤.

from multiprocessing import Process,Pool


def func1(n):
    return n * n

def call_back_func(ret):        # 这里的ret 传的是func1的结果.
    with open("回调内容","w") as f:
        f.write(str(ret))




if __name__ == '__main__':

    pool = Pool(4)
    ret = pool.apply_async(func1,args=(25,),callback=call_back_func)
    # callback后面跟回调函数, 即把func1的结果传进callback回调函数中去执行,因为调用者拿不到
    # 回调函数的返回值, 所以只能将返回值写进文件或者数据库里.

    print(ret.get())

3、进程间的通信　　

　　多进程共同去处理共享数据的时候，就和我们多进程同时去操作一个文件中的数据是一样的，不加锁就会出现错误的结果，进程不安全的，所以也需要加锁

　　数据共享----Manager模块

　　　　给Manager对象里面传入你要共享的数据, 然后操作数据时一样要上锁、解锁.

from multiprocessing import Process,Lock,Manager

def func1(dic,loc):
    with loc:                   # with loc 做了两件事: loc.acquire() 和 loc.release(), 自动上锁和解锁
        dic["numb"] -= 1



if __name__ == '__main__':
    m = Manager()
    loc = Lock()
    dic = m.dict({"numb": 100})
    p_lst = []
    for i in range(100):
        p = Process(target=func1, args=(dic,loc))
        p.start()
        p_lst.append(p)
    [pp.join() for pp in p_lst]
    print(">>>>>>",dic["numb"])