进程间通信及python实现

进程间通信方式：

系统可以运行多进程，有时进程间需要通信传递信息，进程间通信的方式有：管道、消息队列、共享内存、信号、信号量、套接字

管道：

原理：在内存中开辟管道空间，生成管道对象，多个进程对管道对象进行读写，实现进程间通信，但是multiprocessing模块的管道通信只能在亲缘关系的进程中通信

from multiprocessing import Pipe
from multiprocessing import Process
#父进程中创建管道对象(双向管道)
fd_one, fd_two = Pipe(duplex=True)
#将进程的功能封装成函数，使用Process创建进程
def pro01_func():
	a = 1
	fd_one.send(a)
	data = fd_one.recv()
	if data:
		a = a + data
		print(a)
def pro02_func():
	b = 1
	data = fd_two.recv()
	if data == 1:
		fd_two.send(b)
#将函数加入列表中
pro_list = [pro01_func, pro02_func]
data_list = []
#创建多进程
for pro in pro_list:
	p = Process(target=pro)
	data_list.append(p)
	p.start()
#对进程进行回收
for pro_start in data_list:
	pro_start.join()

消息队列

原理：在内存中开辟队列空间，进程向队列中写入消息，其他进程从队列中读取消息

#创建2个子进程，一个进程向消息队列中传入消息，另一个进程从队列中获取消息并打印显示
from multiprocessing import Process, Queue
from time import sleep
from random import randint
#创建消息队列对象，设置队列中消息最大数量
q = Queue(maxsize=4, block=True, timeout=2)
def child_pro_get():
	while not q.empty():
		print(q.get())
		sleep(2)
def child_pro_put():
	while True:
		p.put(randint(1,10))
		sleep(1.5)
p_get = Process(target=child_pro_get)
p_put = Process(target=child_pro_put)
p_put.start()
p_get.start()
#程序会报错，因为消息队列容量满时继续添加会报错

共享内存

原理：在内存中创建一个空间，用来存储进程间通信的信息，但每次对共享内存进行存入都会覆盖上次的消息，由于结构复杂，所以操作的效率高

from multiprocessing import Process, Value, Array
v = Value(ctype='i', 10)
def pro01():
	v.value += 1
	print('pro01:', v.value)
def pro02():
	v.value -= 1
	print('pro02:',v.value)
pro_01 = Process(target=pro01)
pro_02 = Process(target=pro02)
pro_01.start()
pro_02.start()
pro_01.join()
pro_02.join()
print('parent:', v.value)

信号量

原理：给定一个数字对多个进程可见，当信号量达到一定量时，对进程进行操作

from multiprocessing import Semaphore, Process
from time import sleep
#创建信号量对象，初始化信号量的值
sem = Semaphore(1)
def func_pro():
	while True:
		sem.release() #对信号量进行+1操作
		if sem.get_value() == 5: #获取信号量的值
			break
		sleep(1)
pro = Process(target=func_pro)
pro.start()
pro.join()