python进程间通信

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()