【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()

 

 

 
posted @ 2020-09-29 23:49  charseki  阅读(243)  评论(0编辑  收藏  举报