进程间通信

---pipe管道

概念：在内存中开辟管道空间，生产一个管道对象，多个进程使用同一个管道

'''管道通信
multiprocessing中管道通信只能用于有亲缘关系进程中，即父子进程，兄弟进程
2.管道对象在父进程中创建，子进程通过父进程获取
'''
from multiprocessing import Pipe,Process
#创建管道
fd1,fd2 = Pipe(duplex=True)     #默认为True双向管道，双方都写读，如果是单向，只能一边读，一边写
def app1():
    print('启动app1,请登录')
    print('请求app2 授权')
    fd1.send('app1 请求登录')       #写入管道
    data = fd1.recv()               #从管道接受数据
    print('登录成功',data)
def app2():
    print('启动app2')
    data = fd2.recv()       #recv阻塞函数，如果管道内没有内容，会阻塞
    print(data)
    fd2.send('账号：alex,密码：123')
things = [(app1,fd1),(app2,fd2)]
jobs = []
for th in things:
    print(th[0],th[1])
    p = Process(target=th[0])
    jobs.append(p)
    p.start()
for job in jobs:
    job.join()

---基于消息队列

基本用法

q = Queue(maxsize=0)
功能: 创建队列对象
参数：最多存放消息个数
返回值：队列对象

q.put(data,[block,timeout])
功能：向队列存入消息
参数：data 要存入的内容
block 设置是否阻塞 False为非阻塞
timeout 超时检测

q.get([block,timeout])
功能：从队列取出消息
参数：block 设置是否阻塞 False为非阻塞
timeout 超时检测
返回值： 返回获取到的内容

q.full() 判断队列是否为满
q.empty() 判断队列是否为空
q.qsize() 获取队列中消息个数
q.close() 关闭队列

'''
消息队列，先进先出原则
'''
from multiprocessing import Process,Queue
from random import randint
from time import sleep

q = Queue(maxsize=10)

def handle():
    for i in range(6):
        x = randint(1,33)
        q.put(x)            #消息入队
    q.put(randint(1,16))

def request():
    while True:
        print('摇号中')
        sleep(1)
        print(q.get(3))          #出队列
        if q.empty():
            break
p1 = Process(target=handle)
p2 = Process(target=request)
p1.start()
p2.start()
p1.join()
p2.join()

---共享内存

在内存中开辟一块空间，进程可以进行写读，但是每次写入内容会覆盖之前的内容

缺点：一次只能存一组数或一个数

value:只能存放一个数

　　obj = Value(ctype,data)
　　功能 ： 开辟共享内存
　　参数 ： ctype 表示共享内存空间类型 'i' 'f' 'c'
　　data 共享内存空间初始数据
　　返回值：共享内存对象
　　obj.value 对该属性的修改查看即对共享内存读写

array:一次存放一组数

obj = Array(ctype,data)
　　功能： 开辟共享内存空间
　　参数： ctype 表示共享内存数据类型
　　data 整数则表示开辟空间的大小，其他数据类型表示开辟空间存放的初始化数据
　　返回值：共享内存对象
　　Array共享内存读写： 通过遍历obj可以得到每个值，直接可以通过索引序号修改任意值。
　　* 可以使用obj.value直接打印共享内存中的字节串

'''
value，开辟一个单一的共享内存空间
共享内存中只能存入一个值
'''
from multiprocessing import Value,Process
import time
import random
#创建共享内存
money = Value('i',5000)
#操作共享内存
def man():
    for i in range(30):
        time.sleep(0.2)
        money.value += random.randint(1,1000)

def girl():
    for i in range(30):
        time.sleep(0.2)
        money.value -= random.randint(1,500)

p1 = Process(target=man)
p2 = Process(target=girl)
p1.start()
p2.start()
p1.join()
p2.join()
print('余额：',money.value)

--信号量

　　sem = Semaphore(num)
　　功能 ： 创建信号量对象
　　参数 ： 信号量的初始值
　　返回值 ： 信号量对象

　　sem.acquire() 将信号量减1 当信号量为0时阻塞
　　sem.release() 将信号量加1
　　sem.get_value() 获取信号量数量

'''
sem 信号量演示
思路：信号量数量相当于资源，执行任务必须消耗资源
'''

from multiprocessing import Semaphore,Process
from time import sleep
import os

#创建信号量(做多允许三个任务同时执行)
sem = Semaphore(3)
#任务函数
def fun1():
    sem.acquire()       #执行一个任务必须消耗一个信号量
    print(' 执行任务1--',os.getpid())
    sleep(5)
    print('完成任务1--',os.getpid())
    sem.release()           #任务执行完成，再增加一个信号量

#10个任务需要执行
jobs=[]
for i in range(9):
    p = Process(target=fun1)
    jobs.append(p)
    p.start()
for i in jobs:
    i.join()