进程之间有很多通信的方式，除了socket，还有pipe和queue。
pipe
#encoding:utf-8
import multiprocessing
def proc1(pipe):
pipe.send("hello")
print ("proc 1 : ",pipe.recv())
def proc2(pipe):
print ("proc 2 : ",pipe.recv())
pipe.send("hello ,too")
#创建一个管道 这个管道是双向的
pipe=multiprocessing.Pipe()
#pipe[0] 表示管道的一端，pipe[1] 表示管道的另外一端
#对ｐｉｐｅ的某一端调用ｓｅｎｄ方法来传送对象，在另外一端使用ｒｅｃｖ来接收
p1=multiprocessing.Process(target=proc1,args=(pipe[0],))
p2=multiprocessing.Process(target=proc2,args=(pipe[1],))
p1.start()
p2.start()
p1.join()
p1.join()
queue
#encoding:utf-8
import multiprocessing
import time
import os
def inputq(queue):
info=str(+os.getpid())+ ' put : '+str(time.ctime())
queue.put(info)
time.sleep(2)
info=queue.get()
print (info)
def outputq(queue):
info=queue.get()
print (info)
queue.put(str(time.ctime()))
queue=multiprocessing.Queue(10)
p1=multiprocessing.Process(target=inputq,args=(queue,))
p2=multiprocessing.Process(target=outputq,args=(queue,))
p1.start()
p2.start()
p1.join()
p2.join()
顺便提一下，两个进程的去访问一个全局变量的情况
在python里面创建两个进程，两个进程同时去访问，修改一个全局变量i。看看这两个进程其中一个进程修改全局变量i，另外一个进程去访问变量，看看这个变量是否被修改。
执行如下代码：
from time import sleep,ctime
from multiprocessing import Process
i=100
def proc1():
global i
count=1
while True:
print ('proc1 >>',i)
i=i+2
sleep(1)
if count==5:
break
count=count+1
def proc2():
global i
count=1
while True:
print ('proc2 >>>>>>>>',i)
i=i-3
sleep(1)
if count==5:
break
count=count+1
print ("start")
p1=Process(target=proc1)
p2=Process(target=proc2)
p1.start()
p2.start()
p1.join()
p2.join()
print ("end")
看一下运行结果：
image.png
可以看到，一个进程修改全变变量，另外一个进程根本不会影响。
对这个问题的回答，就要涉及到进程的内存模型了，每个进程的内存空间都是独立的，都是4G，每个内存空间都是独立的，有自己的代码段，数据段，堆，栈等。所以，一个进程更改变量，另外一个进程根本不会受到影响。
demo4,5
下面的要讲的是，进程的通信的方式，比如队列queue和pipe来实现进程通信。
关于queue，有一个是线程安全的，有一个是线程不安全的。
1.from Queue import Queue
这个是普通的队列模式，类似于普通列表，先进先出模式，get方法会阻塞请求，直到有数据get出来为止
2.from multiprocessing.Queue import Queue
这个是多进程并发的Queue队列，用于解决多进程间的通信问题。普通Queue实现不了。
例如来跑多进程对一批IP列表进行运算，运算后的结果都存到Queue队列里面，这个就必须使用multiprocessing提供的Queue来实现
举个例子：
#import Queue
from time import sleep,ctime
from multiprocessing import Process,Queue
def pro1(q):
while True:
val=q.get(True)
print '>>>>in por1:',val
def pro2(q):
while True:
val=q.get(True)
print 'in por2:',val
q=Queue()
for i in range(101):
q.put(i)
print 'start : ',ctime()
p1=Process(target=pro1,args=(q,))
p2=Process(target=pro2,args=(q,))
p1.start()
p2.start()
sleep(20)
print 'end : ',ctime()
pr.terminate()
运行结果：
image.png
分析运行结果，这是一个进程安全的队列，如果队列里面存放这个0-29，如果这个数字被进程pro1 被get，那么这个数字就不在了。所以，0-29只会被print一次。
下面再举一个普通queue的例子，代码如下：
#coding:utf-8
import Queue
from time import sleep,ctime
#from multiprocessing import Queue
from multiprocessing import Process
def pro1(q):
while True:
val=q.get(True)
print '>>>>in por1:',val
def pro2(q):
while True:
val=q.get(True)
print 'in por2:',val
#如果頭文件是import Queue
q=Queue.Queue()
#如果頭文件是from multiprocessing import Queue ，那執行
#q=Queue()
for i in range(20):
q.put(i)
print 'start : ',ctime()
p1=Process(target=pro1,args=(q,))
p2=Process(target=pro2,args=(q,))
p1.start()
p2.start()
sleep(20)
print 'end : ',ctime()
pr.terminate()
运行结果：
image.png
普通队列，两个进程都会把队列里面的数字各打印一次,线程安全的队列只是打印一次。
