多进程的数据共享

老师的博客：http://www.cnblogs.com/Eva-J/articles/8253549.html#_label14

Pipe

pipe是管道但是不是很推荐使用，因为有着不安全的危险，queue就相当于pipe加上lock，比较安全，但是的注意他们的close的时间，详见python3中的day38的笔记

下面是老师的代码

from multiprocessing import Lock,Pipe,Process
def producer(con,pro,name,food):
    con.close()
    for i in range(100):
        f = '%s生产%s%s'%(name,food,i)
        print(f)
        pro.send(f)
    pro.send(None)
    pro.send(None)
    pro.send(None)
    pro.close()

def consumer(con,pro,name,lock):
    pro.close()
    while True:
            lock.acquire()
            food = con.recv()
            lock.release()
            if food is None:
                con.close()
                break
            print('%s吃了%s' % (name, food))
if __name__ == '__main__':
    con,pro = Pipe()
    lock= Lock()
    p = Process(target=producer,args=(con,pro,'egon','泔水'))
    c1 = Process(target=consumer, args=(con, pro, 'alex',lock))
    c2 = Process(target=consumer, args=(con, pro, 'bossjin',lock))
    c3 = Process(target=consumer, args=(con, pro, 'wusir',lock))
    c1.start()
    c2.start()
    c3.start()
    p.start()
    con.close()
    pro.close()
# pipe 数据不安全性
# IPC
# 加锁来控制操作管道的行为 来避免进程之间争抢数据造成的数据不安全现象

# 队列 进程之间数据安全的
# 管道 + 锁

manager

老师的代码

from multiprocessing import Manager,Process,Lock
def main(dic,lock):
    dic['count'] -= 1

if __name__ == '__main__':
    m = Manager()
    l = Lock()
    dic=m.dict({'count':100})
    p_lst = []
    for i in range(50):
        p = Process(target=main,args=(dic,l))
        p.start()
        p_lst.append(p)
    for i in p_lst: i.join()
    print('主进程',dic)

运行几次后，你会发现得到的结果不一样，所以也存在数据不安全的现象，所以一般推荐使用queue比较安全，queue，pipe都是可是实现数据通信的。

数据池pool

参数介绍：

Pool([numprocess [,initializer [, initargs]]]):创建进程池

1 numprocess:要创建的进程数，如果省略，将默认使用cpu_count()的值

2 initializer：是每个工作进程启动时要执行的可调用对象，默认为None

3 initargs：是要传给initializer的参数组

1 p.apply(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。
2 '''需要强调的是：此操作并不会在所有池工作进程中并执行func函数。如果要通过不同参数并发地执行func函数，
必须从不同线程调用p.apply()函数或者使用p.apply_async()'''
3 
4 p.apply_async(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。
5 '''此方法的结果是AsyncResult类的实例，callback是可调用对象，接收输入参数。当func的结果变为可用时，
将理解传递给callback。callback禁止执行任何阻塞操作，否则将接收其他异步操作中的结果。'''
6    
7 p.close():关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成
8 
9 P.jion():等待所有工作进程退出。此方法只能在close（）或teminate()之后调用

1 方法apply_async()和map_async（）的返回值是AsyncResul的实例obj。实例具有以下方法
2 obj.get():返回结果，如果有必要则等待结果到达。timeout是可选的。如果在指定时间内还没有到达，将引发一场。如果远程操作中引发了异常，它将在调用此方法时再次被引发。
3 obj.ready():如果调用完成，返回True
4 obj.successful():如果调用完成且没有引发异常，返回True，如果在结果就绪之前调用此方法，引发异常
5 obj.wait([timeout]):等待结果变为可用。
6 obj.terminate()：立即终止所有工作进程，同时不执行任何清理或结束任何挂起工作。如果p被垃圾回收，将自动调用此函数

进程池的效率要高许多，详见老师的博客

import time
from multiprocessing import Pool,Process
def func(n):
    n=n
    for i in range(10):
        n+=i
    print(n)
if __name__ == '__main__':
    start = time.time()
    pool = Pool(5)               # 5个进程
    pool.map(func,range(100))    # 100个任务
    t1 = time.time() - start

    start = time.time()
    p_lst = []
    for i in range(100):#100个任务
        p = Process(target=func,args=(i,))
        p_lst.append(p)
        p.start()
    for p in p_lst :p.join()
    t2 = time.time() - start
    print(t1,t2)

进程池的三种调用方式：

def fun(name):
    for i in range(10):

        print('my name is %s'%name,getpid())
if __name__=='__main__':
    pool=Pool(3)
    pool.map(fun,(1,2,3,4,5,6,7,8,9,10))
    print('end')
    '''你可以发现进程号最多最多只有3个
    ,你可以看end的输出始终一直在最后面）
    map（函数名，加上一个可迭代的对象）'''

import os
import time
from multiprocessing import Pool
def func(n):
    print('start func%s'%n,os.getpid())
    time.sleep(1)
    print('end func%s' % n,os.getpid())

if __name__ == '__main__':
    p = Pool(5)
    for i in range(10):
        p.apply_async(func,args=(i,))
    p.close()  # 结束进程池接收任务
    p.join()   # 感知进程池中的任务执行结束
'''注意此种调用方法时真真的异步，如果你不加入jion的的话你连打印的值就不可能显示出来
这个方法时一个一个的调，只是进程在那几个进程池中而已，而且传参的方式也不一样，前面一个是位置参数，后面一个是
第二个是默认参数须要=，具体自己看源码'''

import os
import time
from multiprocessing import Pool
def func(n):
    print('start func%s'%n,os.getpid())
    time.sleep(1)
    print('end func%s' % n,os.getpid())

if __name__ == '__main__':
    p = Pool(5)
    for i in range(10):
        p.apply(func,args=(i,))
    p.close()  # 结束进程池接收任务,及不能再想进池中加入显得代码，就是不能调用p了
    p.apply(func,args=(10000,))
'''注意此种调用方法是同步的
这个方法时一个一个的调，只是进程在那几个进程池中而已，而且传参的方式也不一样，前面一个是位置参数，后面一个是
第二个是默认参数须要=，具体自己看源码
其实apply_async的形式是一样的
不用加join'''

import time
from multiprocessing import Pool
def func(name):
    print('你传递的参数是%s'%name)
    return '你的返回值'
if __name__=='__main__':
    p=Pool(2)

    a=p.apply(func,args=('alex',))
    b=p.apply_async(func, args=('jin',))
    c = p.map(func, ('alex', 1))
    time.sleep(1)
    print(a)
    print(b)
    print(c,type(c))
    # print(c)
'''输出：你传递的参数是alex
你传递的参数是jin
你传递的参数是alex
你传递的参数是1
你的返回值
<multiprocessing.pool.ApplyResult object at 0x0000000002BE8198>
['你的返回值', '你的返回值'] <class 'list'>
说明了apply是有返回值的
而apply_async这是一种方法
map由于其特殊性，返回值所有函数返回值组成的list'''

总结一下：

1.三种放方法的调用方式不同，map的调用时的参数是位置参数，必须传，第一个是函数名字，而且第二个是可迭代的对象，调用的是一群函数，返回值是list。

2.apply是第一个是位置参数，第二个是默认参数了，调用的是一个函数，而且有返回值

3.apply_asnyc与applyl一样的调用，也只能调用一个函数

4.比较：apply与map是同步的。不需要添加join

　　而apply_async如果主进程的时间太快则不会打印其内容的

5.p.close就是不能再往里里面添加新的进程了，pool里面的代码运行完毕后就结束了

更正一下：在apply_async是能拿到返回值的，但是需要.get（）来调用的

map也是异步的，当时自动的添加了join，阻塞了，所以显示觉得是同步的。

另外，如果想要apply-async到达阻塞的效果，有两种放法，一种是通过get获取返回值，另外一种是先close在join也能达到前面的效果，但是再也不能往池子里加入代码了

回调函数

from multiprocessing import Pool
from time import sleep
def func(name):
    return name
def func2(age):
    print('my name is %s'%age)
    return 'i am this func2’s retrun'
if __name__=='__main__':
    p=Pool(5)
    a= p.apply_async(func,args=('alex',),callback=func2)
    # b = p.apply(func, args=('alex',), callback=func2)
    p.close()
    p.join()
    print(a)
    # print(b)
'''输出结果;my name is alex
<multiprocessing.pool.ApplyResult object at 0x0000000002BE35F8>
只有apply_aspnc才有回调函数，而且就是一样接受不到返回值，只是方法
原理是前面的函数的返回值带入callback函数的参数'''

from multiprocessing import Pool
def func1(n):
    return n+1

def func2(m):
    print(m)

if __name__ == '__main__':
    p = Pool(5)
    for i in  range(10,20):
        a=p.apply_async(func1,args=(i,),callback=func2)
        a.get()
#看一下这个是通过，get来达到依次执行的效果的

 下面是老师的总结，可以看一下

# 管道
# 数据的共享 Manager dict list
# 进程池
    # cpu个数+1
    # ret = map(func,iterable)
        # 异步 自带close和join
        # 所有结果的[]
    # apply
        # 同步的:只有当func执行完之后,才会继续向下执行其他代码
        # ret = apply(func,args=())
        # 返回值就是func的return
    # apply_async
        # 异步的:当func被注册进入一个进程之后,程序就继续向下执行
        # apply_async(func,args=())
        # 返回值 : apply_async返回的对象obj
        #          为了用户能从中获取func的返回值obj.get()
        # get会阻塞直到对应的func执行完毕拿到结果
        # 使用apply_async给进程池分配任务,
        # 需要先close后join来保持多进程和主进程代码的同步性

。