python_并发编程——管道

1.管道

from multiprocessing import Pipe

conn1,conn2 = Pipe()    #返回两个值
conn1.send('wdc')   #发送
print(conn2.recv()) #接收
conn2.send('yhf')
print(conn1.recv())

结果：~双向通信

2.在进程中传递数据

from multiprocessing import Pipe,Process

class Pr1(Process):
    def __init__(self,conn1):
        super().__init__()
        self.conn1 = conn1
    def run(self):
        self.conn1.send('吃了吗？')

if __name__ == '__main__':
    conn1,conn2 = Pipe()
    p = Pr1(conn1)
    p.start()
    print(conn2.recv())

结果：

 解决当管道内数据为空时，还在继续获取数据时造成的阻塞问题。

from multiprocessing import Pipe,Process

class Pr1(Process):
    def __init__(self,conn1,conn2):
        super().__init__()
        self.conn1 = conn1
        self.conn2 = conn2
    def run(self):
        self.conn2.close()  #关闭conn2
        while True:
            try:
                print(self.conn1.recv())
            except EOFError:    #当其他所有的conn端口都被关闭，只剩下一个conn端口还在获取管道内的数据，而管道内已经空了的时候就会报EOFError错误。
                self.conn1.close()   #关闭conn1
                break

if __name__ == '__main__':
    conn1,conn2 = Pipe()
    p = Pr1(conn1,conn2)
    p.start()
    conn1.close()   #关闭conn1
    for i in range(10):
        conn2.send('吃了吗？')
    conn2.close()  #关闭conn2

结果：输出10次数据，然后结束全部进程。

管道实现生产者消费者问题：

from multiprocessing import Pipe,Process
import time
import random
class Producer(Process): #生产者类
    def __init__(self,pro,con,name,food):
        super().__init__()
        self.pro = pro
        self.con = con
        self.name = name
        self.food = food
    def run(self):
        self.con.close()
        for i in range(4):
            time.sleep(random.randint(1,3))
            f = '{}生产了第{}个{}'.format(self.name,i,self.food)
            print(f)
            self.pro.send(f)
        self.pro.close()
class Consumer(Process):
    def __init__(self,pro,con,name):
        super().__init__()
        self.pro = pro
        self.con = con
        self.name = name
    def run(self):
        self.pro.close()
        while True:
            try:
                f = self.con.recv()
                print('{}吃了{}'.format(self.name,f))
                time.sleep(random.randint(1,3))
            except EOFError:
                self.con.close()
                break

if __name__ == '__main__':
    con,pro = Pipe()
    p1 = Producer(pro,con,'wdc','包子')
    p1.start()
    c1 = Consumer(pro,con,'yhf')
    c1.start()
    con.close()
    pro.close()

结果：

如果同时有两个消费者同时拿到管道中相同的数据，则会报错，管道中的数据是不安全的。

可以以用加锁来避免进程直接争抢数据造成的数据不安全现象。但是队列是安全的，队列就是基于管道+锁