并发编程

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

# 生产者消费者模型，因为消费者一直在等待消费，会卡在那里，
# 首先应该确保生产者已经完全生产完，所以需要使用join方法
# 然后为了确保消费者知道已经接收完数据，所以需要将在列表后面加入None数据，有几个消费者就传入几个None

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