多线程必备技能 - Queue (队列)

前期

1. Queue模块提供了同步线程安全的队列类，包括:
   FIFO (先入先出)队列 Queue
   LIFO (后入先出)队列 LifoQueue
   优先级队列 PriorityQueue
   这些队列都提供了锁，可以直接使用队列来实现线程间的同步
2. 反正就是给我这种小白写多线程中直接使用就好了

Queue 常用模块

Queue.Queue(maxsize=0)				# FIFO， 如果maxsize小于1就表示队列长度无限
Queue.LifoQueue(maxsize=0)			# LIFO， 如果maxsize小于1就表示队列长度无限
Queue.qsize()						# 返回队列的大小
Queue.empty()						# 如果队列为空，返回True,反之False
Queue.full()						# 如果队列满了，返回True,反之False，Queue.full 与 maxsize 大小对应
Queue.put(item, [block[, timeout]])	# 写队列，timeout等待时间 
Queue.get([block[, timeout]])		# 获取队列，timeout等待时间
Queue.get_nowait()					# 相当于Queue.get(False)，非阻塞方法
Queue.queue.clear()					# 清空队列
Queue.join()     					# 实际上意味着等到队列为空，再执行别的操作
Queue.task_done()					# 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
									# 每个get()调用得到一个任务，接下来task_done()调用告诉队列该任务已经处理完毕。

Queue 例子

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Date    : 2020/4/22 9:54
# @File    : Queue_test.py
# @Author  : BenLam
# @Link    : https://www.cnblogs.com/BenLam/
# @Version : PyCharm


from queue import Queue,LifoQueue,PriorityQueue
from queue import deque

#先进先出队列
q = Queue(maxsize=10)

#后进先出队列
lq = LifoQueue(maxsize=11)

#优先级队列
pq = PriorityQueue(maxsize=10)

for _ in range(10):
    q.put(_)
    lq.put(_)
    pq.put(_)

print("先进先出队列: %s ;是否为空: %s ;多大, %s ;是否满, %s" %(q.queue,q.empty(),q.qsize(),q.full()))
print("后进先出队列: %s ;是否为空: %s ;多大, %s ;是否满, %s" %(lq.queue,lq.empty(),lq.qsize(),lq.full()))
print("优先级队列:  %s ;是否为空: %s ,多大, %s ;是否满, %s " %(pq.queue,pq.empty(),pq.qsize(),pq.full()))

print(f" q: {q.get()} \nlq: {lq.get()} \npq: {pq.get()}")

print("先进先出队列: %s ;是否为空: %s ；多大, %s ;是否满, %s" %(q.queue,q.empty(),q.qsize(),q.full()))
print("后进先出队列: %s ;是否为空: %s ;多大, %s ;是否满, %s" %(lq.queue,lq.empty(),lq.qsize(),lq.full()))
print("优先级队列: %s ;是否为空: %s ,多大, %s ;是否满, %s" %(pq.queue,pq.empty(),pq.qsize(),pq.full()))

# === === === === === === === === === === === ===
print("=== === 双端队列 === ===")
dq=deque(['1','2'])
print(dq)
dq.append('c')
print(dq)
print(dq.pop())
print(dq)
print(dq.popleft())
print(dq)
dq.appendleft('d')
print(dq)
print(len(dq))
print("=== === 双端队列 结束 === ===")
"""
打印:
    先进先出队列: deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) ;是否为空: False ;多大, 10 ;是否满, True
    后进先出队列: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] ;是否为空: False ;多大, 10 ;是否满, False
    优先级队列:  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] ;是否为空: False ,多大, 10 ;是否满, True
         q: 0
        lq: 9
        pq: 0
    先进先出队列: deque([1, 2, 3, 4, 5, 6, 7, 8, 9]) ;是否为空: False ；多大, 9 ;是否满, False
    后进先出队列: [0, 1, 2, 3, 4, 5, 6, 7, 8] ;是否为空: False ;多大, 9 ;是否满, False
    优先级队列: [1, 3, 2, 7, 4, 5, 6, 9, 8] ;是否为空: False ,多大, 9 ;是否满, False
    === === 双端队列 === ===
        deque(['1', '2'])
        deque(['1', '2', 'c'])
            c
        deque(['1', '2'])
            1
        deque(['2'])
        deque(['d', '2'])
            2
    === === 双端队列 结束 === ===
    [Finished in 0.6s]
"""

生产消费者

• 生产消费者就是 → 生产者/消费者模式，反正我们就叫它为：生肖（生消）
• 生消并非 GOF 自带模式，不知道 GOF 可以参考我另一篇笔记《2020年 - 在家学习汇总》
• | 【 生产者 】 → → → [ 缓冲区 ] → → → 【 消费者 】
• 生产者 - 负责产生数据，放入缓冲区
• 消费者 - 负责缓冲区取值并处理
• 优点：
  • 解耦
    1. 缓冲区的存在可以让他俩降低互相之间的依赖性，老产修改代码不影响老消
  • 并发
    1. 他俩不是直接调用，而是两个独立的个体，可以说老产把数据摊牌在缓冲区完事了；
    2. 老消又不用跪着向想他要饭，直接从缓冲区取数据就好了；
    3. 参考（饭堂阿姨把饭菜+饭勺放在桌上，再也不怕阿姨帕金森模式）

标签：False,队列,Queue,为空,lq,print,多线程
来源： https://www.cnblogs.com/BenLam/p/12752389.html