并发编程 - 进程 - 1.队列的使用/2.生产者消费者模型/3.JoinableQueue

1.队列的使用：
　　队列引用的前提： 多个进程对同一块共享数据的修改：要从硬盘读文件，慢，还要考虑上锁：
   　　 所以就出现了 队列  和 管道 都在内存中（快）； 队列 = 管道 + 上锁
 
　　用队列的目的：
    　　进程间通信（IPC），队列可以放任意类型的数据，应该放小东西，
    　　q = Queue(3)
    　　get put full empty
 
　　队列作用：
   　　 多个进程之间通信使用的，一个进程将数据放到队列里面，另外一个进程从队列里面取走数据，干的是进程之间通信的活

 from multiprocessing import Queue
 
 q = Queue(3)
 q.put('hello')
 q.put({'a':1})
 q.put([3,3,3])
 
 print(q.full())  # 查看队列是否满了
 # q.put(2)  # 这里会卡住，直到队列中被取走一个
 
 print(q.get())
 print(q.get())
 q.put(2)
 print(q.get())
 print(q.get())
 print(q.empty())  # 查看队列是否为空
 print(q.get())  # 取完数据后，再取，就卡住了

2.生产者消费者模型：
　　生产者：
   　　 生产者指的是生产数据的任务
　　消费者：
   　　 消费者指的是处理数据的任务
 
　　生产者与消费者模型：
   　　 生产者与消费者之间引入一个容器(队列)：
    　　生产者《---》队列《---》消费者
 
    　　好处：程序解开耦合，生产者与消费者不直接通信
       　　   平衡了生产者与消费者的速度差
 
         　　 生产者：一个进程
          　　消费者：一个进程
          　　进程间通信：队列（IPC）
 
　　如果生产者，消费者，队列组件都在一台机器上：
  　　  集中式：稳定性差，性能问题差
 
　　分布在多台机器上：
   　　 Rabbitmq 用它来实现生产者，消费者模型

 from multiprocessing import Process,Queue
 import time
 
 def producer(q):
     for i in range(10):
         res = '包子%s'%i
         time.sleep(0.5)
         print('生产者生产了%s'%res)
 
         q.put(res)
 
 def consumer(q):
     while True:
         res = q.get()
         if not res:break
         time.sleep(1)
         print('消费者吃了%s'%res)
 
 if __name__ == "__main__":
     # 容器
     q = Queue()
 
     # 生产者们
     p1 = Process(target=producer,args=(q,))
     p2 = Process(target=producer, args=(q,))
     p3 = Process(target=producer, args=(q,))
 
     # 消费者们
     c1 = Process(target=consumer,args=(q,))
     c2 = Process(target=consumer,args=(q,))
 
     p1.start()
     p2.start()
     p3.start()
     c1.start()
     c2.start()
 
     p1.join()
     p2.join()
     p3.join()
     q.put(None)  # 两个消费者，所以放两个None
     q.put(None)
 
     print('主')

3.JoinableQueue:
    q = JoinableQueue()
    q.join()
    q.task_done()

 from multiprocessing import Process,Queue,JoinableQueue
 import time
 
 def producer(q):
     for i in range(2):
         res = '包子%s'%i
         time.sleep(0.5)
         print('生产者生产了%s'%res)
 
         q.put(res)
     q.join()  # 等待队列为空
 
 def consumer(q):
     while True:
         res = q.get()
         if not res:break
         time.sleep(1)
         print('消费者吃了%s'%res)
         q.task_done()  # 消费者发信号，任务结束
 
 if __name__ == "__main__":
     # 容器
     q = JoinableQueue()
 
     # 生产者们
     p1 = Process(target=producer,args=(q,))
     p2 = Process(target=producer, args=(q,))
     p3 = Process(target=producer, args=(q,))
 
     # 消费者们
     c1 = Process(target=consumer,args=(q,))
     c2 = Process(target=consumer,args=(q,))
     c1.daemon = True  # 消费者没有存在的必要，设为守护进程
     c2.daemon = True
 
     p1.start()
     p2.start()
     p3.start()
     c1.start()
     c2.start()
 
     p1.join()
     p2.join()
     p3.join()
 
     print('主')