34 进程2

佚名 6年前 (2019-05-07) 随笔 1018人围观抢沙发百度已收录

9.进程间通信>>>IPC机制

队列:先进先出

SRE实战互联网时代守护先锋，助力企业售后服务体系运筹帷幄！一键直达领取阿里云限量特价优惠。

堆栈:先进后出

队列的特点：

　　1、往队列中存放数据个数大于队列最大存储个数，程序会阻塞

　　2、队列.get()：取数据，get一次就取一个，如果队列为空，get会在原地等待队列中有数据过来

　　3、队列.get_nowait()：在队列有数据时，跟get取值一样，当队列没有数据时，直接报错

　　4、队列.empty()：判断队列是否为空，需要注意的是，在并发的情况下，这个方法判断不准确！

　　5、队列.full()：判断是否达到队列的最大存储个数

关于队列

from multiprocessing import Queue
q = Queue(9) # 产生一个最多能够存放9个数据的队列

q.put(1)
q.put(3)
q.put(4)
print(q.full())
q.put(2)
q.put(5)

for i in range(4):
    q.put(i)

print(q.get()) # 取数据，get一次就取一个；有取无等 print(q.get())
print(q.get())
print(q.get_nowait()) # 有数据，取，无则报错
a = q.get_nowait()
print(a, q.qsize)
print(q.empty()) # 判断队列是否为空，但在并发的情况下，判断不准确 >>>:
    False
    9
    1
    3
    4
    2
    5 <bound method Queue.qsize of <multiprocessing.queues.Queue object at 0x000002C2F7348320>>
    False

利用队列 Queue 实现进程间通信

from multiprocessing import Queue, Process


def producer(q):
    q.put('hello baby!')


def consumer(q):
    print(q.get())


if __name__ == '__main__':
    q = Queue()  # 生成一个队列对象
    p1 = Process(target=producer, args=(q,))
    c1 = Process(target=consumer, args=(q,))
    p1.start()
    c1.start()


>>>:
    hello baby!

10.生产者消费者模型(***)

例如：

　　生产者:做包子的  生产数据的 
　　消费者:买包子的 处理数据的  

解决供需不平衡的问题：     
　　定义一个队列，用来存放固定数量的数据    
　　解决一个生产者和消费者不需直接打交道，两者都通过队列实现数据传输  

Queue:管道+锁

from multiprocessing import Process, Queue
import time
import random


def producer(name, food, q):
    for i in range(2):
        data = "%s produce %s No.%s" % (name, food, i)
        time.sleep(random.randint(1,2))
        print(data)
        q.put(data)


def consumer(name, q):
    while True:
        data = q.get()
        if data is None: break
        time.sleep(random.random())
        print('%s ate %s' % (name, data))


if __name__ == '__main__':
    q = Queue()
    p2 = Process(target=producer, args=('大厨tank', '包子', q))
    c2 = Process(target=consumer, args=('Zero', q))
    p2.start()
    c2.start()
    p2.join()　
    # 在生产者生产完数据之后，往队列里面放一个提示性的消息，告诉消费者已经没有数据，你走吧，不要等了
    q.put(None)
    c2.join()

    print('主')


>>>:
    大厨tank produce 包子 No.0
    Zero ate 大厨tank produce 包子 No.0
    大厨tank produce 包子 No.1
    Zero ate 大厨tank produce 包子 No.1
    主

JoinableQueue:

from multiprocessing import Process, JoinableQueue
import time
import random


def producer(name, food, q):
    for i in range(3):
        data = '%s生产的%s %s' % (name, food, i)
        time.sleep(random.random())
        print(data)
        q.put(data)  # 将生产的数据放入队列中


def consumer(name, q):
    while True:
        data = q.get()
        if data is None: break
        time.sleep(random.random())
        print('%s吃了%s' % (name, data))
        q.task_done()  # 告诉你的队列，你已经将数据取出并且处理完毕


if __name__ == '__main__':
    q = JoinableQueue()  # 生成一个队列对象
    p1 = Process(target=producer, args=('大厨a', 'noodle', q))
    c1 = Process(target=consumer, args=('tom', q))
    p1.start()
    c1.daemon = True
    c1.start()
    # 等待生产者生产完所有的数据
    p1.join()
    q.join()  # 等待队列中数据全部取出
    print('主')


>>>:
    大厨a生产的noodle 0
    大厨a生产的noodle 1
    tom吃了大厨a生产的noodle 0
    大厨a生产的noodle 2
    tom吃了大厨a生产的noodle 1
    tom吃了大厨a生产的noodle 2
    主