队列分为线程队列和进程队列。线程队列只用于多个线程之间进行数据交互，不能跨进程通信；进程队列用于父进程与子进程，或者属于同一父进程下多个子进程进行交互，不能跨进程通信。

1、FIFO

FIFO = First in First out，先进先出队列

 1 import queue
 2 
 3 
 4 q = queue.Queue()  # first in first out
 5 
 6 q.put(1)  # 放数据
 7 q.put(2)
 8 q.put("d1")
 9 q.put("d2")
10 
11 print(q.get())
12 print(q.get())
13 print(q.get())
14 print(q.get())
15 print(q.get_nowait())  # 如果用q.get()取不到数据，则会进入卡死状态

2、LIFO

后进先出队列 = Last in First out

 1 import queue
 2 
 3 q1 = queue.LifoQueue()  # last in first out
 4 q1.put(1)
 5 q1.put(2)
 6 q1.put(3)
 7 
 8 print(q1.get())
 9 print(q1.get())
10 print(q1.get())

3、PriorityQueue

优先级队列，Lowest First，越小越优先

 import queue 1 q2 = queue.PriorityQueue()  # 优先级队列(lowest first)
 2 q2.put((10, "druid"))
 3 q2.put((5, "zhangsan"))
 4 q2.put((1, "lisi"))
 5 q2.put((9, "alex"))
 6 
 7 print(q2.get())
 8 print(q2.get())
 9 print(q2.get())
10 print(q2.get())

4、生产者消费者模型

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

为什么要使用生产者和消费者模式

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

什么是生产者消费者模式

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

 1 import threading
 2 import queue
 3 import time
 4 
 5 
 6 q = queue.Queue(maxsize=10)
 7 
 8 
 9 def producer():
10     count = 1
11     while True:
12         q.put("骨头%s" % count)
13         print("制作了骨头", count)
14         count += 1
15         time.sleep(1)
16 
17 
18 def consumer(name):
19     while True:
20         print("[%s]拿到了[%s],并且吃了它" % (name, q.get()))
21         time.sleep(1)
22 
23 
24 p1 = threading.Thread(target=producer,)  # 一个生产者
25 c1 = threading.Thread(target=consumer, args=("alex",))  # 两个消费者轮询吃骨头
26 c2 = threading.Thread(target=consumer, args=("zhangsan",))
27 
28 p1.start()
29 c1.start()
30 c2.start()

来源：https://www.cnblogs.com/Druidchen/p/8482294.html

标签

生产者消费者问题