Python编程：queue队列

2021-10-07 07:03:18

queue队列

先入先出队列 first in first out

import queue

q1 = queue.Queue()

q1.put(1)
q1.put(2)
q1.put(3)

print(q1.get())
print(q1.get())
print(q1.get())
# 1 2 3

后入先出队列 last in first out

import queue

q2 = queue.LifoQueue()

q2.put(1)
q2.put(2)
q2.put(3)

print(q2.get())
print(q2.get())
print(q2.get())
# 3 2 1

优先级队列

import queue

q3 = queue.PriorityQueue()

q3.put((10, 1))
q3.put((9, 2))
q3.put((8, 3))

print(q3.get())
print(q3.get())
print(q3.get())
# (8, 3)  (9, 2)  (10, 1)

生产者消费者模型

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。

该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

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

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。

在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，

那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，

如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。

为了解决这个问题于是引入了生产者和消费者模式。

什么是生产者消费者模式

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。

生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，

所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，

消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，

平衡了生产者和消费者的处理能力。

实例代码

import queue, threading, time

q = queue.Queue(maxsize=10)

def producer(name):
    count = 0
    while True:
        count += 1
        q.put("包子 %s" % count)
        print("%s 生产了一个包子" % name)
        time.sleep(2)

def consumer(name):
    while True:
        print("%s 得到了 %s" % (name, q.get()))

p1 = threading.Thread(target=producer, args=("生产者1",))
c1 = threading.Thread(target=consumer, args=("消费者1",))
c2 = threading.Thread(target=consumer, args=("消费者2",))

p1.start()
c1.start()
c2.start()

阻塞队列

import queue, threading, time

q = queue.Queue()

def producer(name):
    for i in range(5):
        q.put("包子 %s" % i)

    print("等待取走")
    q.join()  # 等待通知，全部取走则继续
    print("全都取走了")


def consumer(name):
    while q.qsize() > 0:
        print("%s 得到了 %s" % (name, q.get()))
        q.task_done()  # 告知一次任务结束

p1 = threading.Thread(target=producer, args=("生产者1",))
p1.start()

c = consumer("消费者")
"""
等待取走
消费者 得到了 包子 0
消费者 得到了 包子 1
消费者 得到了 包子 2
消费者 得到了 包子 3
消费者 得到了 包子 4
全都取走了
"""

码农公寓