python 进程间通信

一 .使用queue来实现进程间的内存共享

#_*_coding:utf-8_*_
from  multiprocessing import Process,Queue
import os,time
def f(q,n):
    q.put([n,'hello'])
if __name__ == '__main__':
    #此queue不是直接导入的import Queue,这个是multiprocessing重新封装的
    q=Queue()
    #循环6个进程
    for i in range(5):
           p=Process(target=f,args=(q,i))
           p.start()
    #等待子进程完毕后在继续执行
    p.join()
    for i in range(q.qsize()):
         print q.get()

显示效果如下：

[0, 'hello', {'aa': 'bb'}]
[1, 'hello', {'aa': 'bb'}]
[2, 'hello', {'aa': 'bb'}]
[3, 'hello', {'aa': 'bb'}]
[4, 'hello', {'aa': 'bb'}]

在队列中可以存储列表，字典等类型，还是很方便的。但是python间进程间共享内存  并不是真正意义的而是需要利用第三方来实现queue就是

 

 

二 .进程锁LOCK

#_*_coding:utf-8_*_
from  multiprocessing import Process,Lock
import os,time
def f(l,i):
    #加锁
    l.acquire()
    print 'hello',i
    #释放锁
    l.release()
if __name__ == '__main__':
    lock=Lock()
    for i in range(5):
           p=Process(target=f,args=(lock,i)).start()
                                                   

显示效果：

hello 0
hello 1
hello 2
hello 3
hello 4

这个lock是完全复刻的线程锁 ，没有什么改动。进程间本身内存就是独立的，没有什么征用资源的问题，所以这个把锁用处不大，但是有的时候可能需要，比如当终端显示的时候，多个进程都用的同一个终端显示。

看看父进程和子进程关系

三.利用 Value,Array   先说明这个方法并不常用，因为有更灵活的方法

from multiprocessing import  Process,Value,Array


def f(n,a,not_share):
    n.value=3.141
    for i in range(len(a)):
        a[i]=-a[i]
    #更改共享内存
    not_share.append(999)
    print 'not_share:',not_share

if __name__ == '__main__':
    #这个是一个普通的列表
    not_share=[1000]
    #这个是导入的方法，可以进程共享内存的,’d‘代表数字并不是随便写的。后面的值也必须是数字
    num=Value('d',123)
    
    #这里的’i‘代表列表，不是随便写的。利用这个方法可以进程间共享
    arr = Array('i',range(10))
    #启动子进程
    p=Process(target=f,args=(num,arr,not_share))
    p.start()
    p.join()

    #可以通过这里的输出看出子进程将这个变量的值改了，注意  num.value，和正常的变量有所不同
    print num.value
    #这里和以前打印列表的方式也不一样，方法都被改造了所以才能实现进程间的共享
    print arr[:]   
    #这里打印普通的列表，发现进程间无法更改内存
    print 'not_share:',not_share

显示内容：

not_share: [1000, 999]       子进程里面修改成功，但是看下面父进程返回的值。并没有修改
3.141           共享内存已经被修改了
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]           共享内存已经被修改了
not_share: [1000]                           父进程打印的列表,子进程并没有修改内存成功

 

四.利用  manager方法：

可以支持的数据类型很多,列表、字典、锁、变量、信号、队列等。

 1 #_*_coding:utf-8_*_
 2 from multiprocessing import  Process,Manager
 3 
 4 def f(d,l):
 5     d[1]='1'
 6     d['2']=2
 7     #将列表内容反转
 8     l.reverse()
 9 
10 
11 if __name__ == '__main__':
12     #先定义一下
13     manager=Manager()
14     #利用manager方法生成一个空字典
15     d=manager.dict()
16     #利用manager方法生成一个列表
17     l=manager.list(range(10))
18     
19     p=Process(target=f,args=(d,l))
20     p.start()
21     p.join()
22      
23     print d
24     print l

显示内容：

{1: '1', '2': 2}
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

父进程中定义的字典和列表内容全部被子进程更改掉了

 

结论：

父进程和子进程内存中肯定是独立的，它们之间的修改就是借助第三方桥梁完成。并不是正真意义上的共享，manager是自带进程锁，在进行修改的时候不必担心多进程同时进行修改的问题。线程才是真正意义上的共享一个内存区域，但

线程不自带锁必须自己加锁。    

manager比较灵活可以实现不同主机间的进程共享(听着好像很牛逼)，但是效率没有Value,Array 高