1.Pipe
通信原理:在内存中开辟管道空间,生成管道操作对象,多个进程使用同一个管道对象进行读写即可实现通信。
"""
pipe.py 管道操作
注意: 1. multiprocessing中提供的通信只用于亲缘关系进程间通信
2. 管道在父进程中创建,子进程从父进程中获取管道对象
"""
from multiprocessing import Process, Pipe
# 创建管道对象
# 参数False 表示fd1 只能 recv , fd2 只能 send
fd1, fd2 = Pipe()
# APP1可以使用app2提供的信息登录
def app1(fd1):
print("启动app1,请登录")
print("请求app2授权")
# 写管道
fd1.send("app1 可以用你的账号登录吗?")
data = fd1.recv()
if data:
print("登录成功:", data)
def app2(fd2):
request = fd2.recv() # 阻塞等待读取管道
print(request)
fd2.send(('Joy', '123')) # 发送python数据类型
if __name__ == '__main__':
p1 = Process(target=app1, args=(fd1,))
p2 = Process(target=app2, args=(fd2,))
p1.start()
p2.start()
p1.join()
p2.join()
2.Queue
通信原理:在内存中建立队列模型,进程通过队列将消息存入,或者从队列取出完成进程间通信。
下面这个夯住了,因为进程函数没有把q作为参数传进去。
from multiprocessing import Queue, Process
from time import sleep
from random import randint
# 创建队列
q = Queue(5) # 最大存储5个消息
def request():
for i in range(10):
x = randint(1, 100)
y = randint(1, 100)
q.put((x, y)) # 写消息队列
print("=============")
print("通道消息个数为-->", q.qsize())
def handle():
while not q.empty():
data = q.get() # 读消息队列
print("x + y = ", data[0] + data[1])
sleep(2)
if __name__ == '__main__':
p1 = Process(target=request)
p2 = Process(target=handle)
p1.start()
p2.start()
p1.join()
p2.join()
修改成下面的就好了(就是把p作为参数传进去了)。
"""
消息队列演示
注意: 消息存入与去除关系为 先入先出
"""
from multiprocessing import Queue, Process
from time import sleep
from random import randint
# 把消息队列对象作为参数传进来
def request(q):
for i in range(10):
x = randint(1, 100)
y = randint(1, 100)
q.put((x, y)) # 写消息队列
print("=============")
print("通道消息个数为-->", q.qsize())
def handle(q):
while not q.empty():
data = q.get() # 读消息队列
print("x + y = ", data[0] + data[1])
sleep(2)
if __name__ == '__main__':
# 创建队列
q = Queue(5) # 最大存储5个消息
p1 = Process(target=request, args=(q,))
p2 = Process(target=handle, args=(q,))
p1.start()
p2.start()
p1.join()
p2.join()
3.共享内存
通信原理:在内中开辟一块空间,进程可以写入内容和读取内容完成通信,但是每次写入内容会覆盖之前内容。下面的例子注意函数传参,把共享的对象传进去。
"""
value.py 开辟共享内存空间
注意: 共享内存中只能有一个值
"""
from multiprocessing import Process, Value
import time
import random
# 创建共享内存
money = Value('i', 5000)
def man(money):
for i in range(30):
time.sleep(0.2)
# 修改共享内存
money.value += random.randint(1, 1000)
print("此时余额为:", money.value)
def girl(money):
for i in range(30):
time.sleep(0.15)
money.value -= random.randint(100, 800)
print("此时余额为:", money.value)
if __name__ == '__main__':
p1 = Process(target=man, args=(money,))
p2 = Process(target=girl, args=(money,))
p1.start()
p2.start()
p1.join()
p2.join()
print("一个月余额:", money.value) # 读取共享内存
"""
array.py
共享内存中存放列表,字节串
"""
from multiprocessing import Process, Array
from time import sleep
# 创建共享内存,初始数据 [1,2,3,4]
# shm = Array('i',[1,2,3,4])
# shm = Array('i',4) # 开辟4个整形的列表空间
shm = Array('c', b'hello')
def fun(shm):
# 共享内存对象可以迭代
for i in shm:
print(i)
shm[0] = b'H' # 修改共享内存
if __name__ == '__main__':
p = Process(target=fun, args=(shm,))
p.start()
p.join()
for i in shm:
print(i)
# h->H
print(shm.value) # 整体打印字节串
4.信号量(信号灯集)
通信原理:给定一个数量对多个进程可见。多个进程都可以操作该数量增减,并根据数量值决定自己的行为。
"""
sem.py 信号量演示
注意: 信号量可以当做是一种资源,执行任务需要消耗信号量资源,
这样可以控制进程执行行为
"""
from multiprocessing import Process, Semaphore
from time import sleep
import os
# 创建信号量资源
sem = Semaphore(3)
# 任务函数 (系统中最多能够同时运行三个该任务)
def handle(sem):
sem.acquire() # 消耗一个信号量
print("%s执行任务" % os.getpid())
sleep(2)
print("%s 拯救了宇宙" % os.getpid())
sem.release() # 增加一个信号量
if __name__ == '__main__':
jobs = []
for i in range(10):
p = Process(target=handle,args=(sem,))
jobs.append(p)
p.start()
for i in jobs:
i.join()