【LenmoCK】Python队列基本使用（生产者消费者模型）

作用

解耦：使程序直接实现松耦合，修改一个函数，不会有串联关系。

提高处理效率：FIFO＝先进先出，LIFO＝后进先出。

队列

Python四种类型的队例：

Queue：FIFO 即first in first out 先进先出

LifoQueue：LIFO 即last in first out 后进先出

PriorityQueue：优先队列，级别越低，越优先

deque：双边队列

 

 

Queue 先进先出队列：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
@File:FifoQueue.py
@E-mail:364942727@qq.com
@Time:2020/9/29 10:43 下午 
@Author:Nobita   
@Version:1.0   
@Desciption:先进先出队列
"""

from queue import Queue

# 基本FIFO队列  先进先出 FIFO即First in First Out,先进先出
# maxsize设置队列中，数据上限，小于或等于0则不限制，容器中大于这个数则阻塞，直到队列中的数据被消掉
q = Queue(maxsize=0)

# 写入队列数据
q.put(0)
q.put(1)
q.put(2)

# 输出当前队列所有数据
print(q.queue)

# 删除队列数据，并返回该数据
q.get()

# 输出当前队列所有数据
print(q.queue)

"""
输出：
deque([0, 1, 2])
deque([1, 2])
"""

LifoOueue 后进先出队列：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
@File:LifoQueue.py    
@E-mail:364942727@qq.com
@Time:2020/9/29 10:50 下午 
@Author:Nobita   
@Version:1.0   
@Desciption:后进先出队列
"""

from queue import LifoQueue

# LIFO即Last in First Out,后进先出。与栈的类似，使用也很简单,maxsize用法同上
# maxsize设置队列中，数据上限，小于或等于0则不限制，容器中大于这个数则阻塞，直到队列中的数据被消掉
lq = LifoQueue(maxsize=0)

# 队列写入数据
lq.put(0)
lq.put(1)
lq.put(2)

# 输出队列所有数据
print(lq.queue)
# 删除队列数据，并返回该数据
lq.get()
# 输出队列所有数据
print(lq.queue)

"""
输出：
deque([0, 1, 2])
deque([0, 1])
"""

优先队列：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
@File:PriorityQueue.py    
@E-mail:364942727@qq.com
@Time:2020/9/29 10:53 下午 
@Author:Nobita   
@Version:1.0   
@Desciption:优先级队列
"""

from queue import PriorityQueue

# 存储数据时可设置优先级的队列
# 优先级设置数越小等级越高
# maxsize设置队列中，数据上限，小于或等于0则不限制，容器中大于这个数则阻塞，直到队列中的数据被消掉
pq = PriorityQueue(maxsize=0)

# 写入队列，设置优先级
pq.put((1, 'aaa'))
pq.put((2, 'bbb'))
pq.put((3, 'ccc'))
pq.put((9, 'ddd'))

# 输出队例全部数据
print(pq.queue)

# 取队例数据，可以看到，是按优先级取的。
pq.get()
print(pq.queue)

"""
输出：
[(1, 'aaa'), (2, 'bbb'), (3, 'ccc'), (9, 'ddd')]
[(2, 'bbb'), (9, 'ddd'), (3, 'ccc')]
"""

双边队列：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
@File:deque.py    
@E-mail:364942727@qq.com
@Time:2020/9/29 10:59 下午 
@Author:Nobita   
@Version:1.0   
@Desciption:双边队列
"""

from collections import deque

# 双边队列
dq = deque(['a', 'b'])

# 增加数据到队尾
dq.append('c')
# 增加数据到队左
dq.appendleft('d')

# 输出队列所有数据
print(dq)
# 移除队尾，并返回
print(dq.pop())
print(dq)
# 移除队左，并返回
print(dq.popleft())
print(dq)

"""
输出：
deque(['d', 'a', 'b', 'c'])
c
deque(['d', 'a', 'b'])
d
deque(['a', 'b'])
"""

生产者消费者模型：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
@File:Producter_Consumer_Model.py    
@E-mail:364942727@qq.com
@Time:2020/9/29 11:04 下午 
@Author:Nobita   
@Version:1.0   
@Desciption:使用Queue实现生产者消费者模型
"""

"""
题目：
1.用一个队列来存储商品
2.创建一个专门生产商品的线程类，当商品数量少于50时，开始生产商品，每次生产500个商品，每生产完一轮，暂停1秒。
2.创建一个专门消费商品的线程类，当商品数量大于10时就开始消费，循环消费，每次消费3个，当商品实例少于10的时候，暂停2秒。
"""

from threading import Thread
from queue import Queue
import time

# 创建一个队列，用来存储商品
q = Queue()


# 生产者和消费者模式
class Producer(Thread):
    """生产者"""

    def run(self) -> None:
        count = 0
        while True:
            if q.qsize() < 50:  # 商品数量少于50时，开始生产商品
                for i in range(500):  # 每次生产500个商品
                    count += 1
                    goods = '--第{}个商品--'.format(count)
                    q.put(goods)
                    print('生产：{}'.format(goods))
                time.sleep(1)


class Consumer(Thread):
    """消费者"""

    def run(self) -> None:
        while True:
            if q.qsize() > 10:  # 商品数量大于10时就开始消费
                for i in range(3):  # 每次消费3个
                    print('消费：{}'.format(q.get()))
            else:
                time.sleep(2)


if __name__ == '__main__':
    # 创建一个线程来生产
    p = Producer()
    p.start()
    # 创建五个线程来消费
    for i in range(5):
        c = Consumer()
        c.start()