14、第七 - 网络编程基础 - 队列queue和生产者消费者模型

 

 

1、Python中的Queue库讲解

Python中的Queue库讲解
　　Queue是python标准库中的线程安全的队列（FIFO）实现,提供了一个适用于多线程编程的先进先出的数据结构，即队列，用来在生产者和消费者线程之间的信息传递。python3中是queue.Queue；python2中是Queue.Queue。业务环境中，一般会第三方工具代替。如：Redis、Httpsqs、activeMQ等

常使用的语法有：

• class queue.Queue(maxsize=0)  #先入先出
• class queue.LifoQueue(maxsize=0)  #后入先出
• class queue.PriorityQueue(maxsize=0)  #存储数据时可设置优先级的队列
• class queue.put((2,"code"))  #把数据写到队列中，如果超出maxsize值，put的时候进程就会被卡死。
• class queue.get()  #从队列中取数据
• class queue.get_nowait()  #这个函数当队列取完之后，以报错的方式提示已经提示queue.Empty，可以利用抛异常的方式抓取。
• class queue.qsize() #标注取数值的位置，如果为零说明已经取完
• class queue.full()  #这个是提示队列是否已经存满
• class queue.join()  #阻塞打印,阻止程序往下执行
• class queue.empty()  #可以这个参数来判断队列是否消费完成
• class queue.task_done()  #之前入队的一个任务已经完成。由队列的消费者线程调用。每一个get()调用得到一个任务，接下来的task_done()调用告诉队列该任务已经处理完毕。如果当前一个join()正在阻塞，它将在队列中的所有任务都处理完时恢复执行（即每一个由put()调用入队的任务都有一个对应的task_done()调用）。

A、FIFO队列
class queue.Queue(maxsize=0)
　　FIFO即First in First Out,先进先出（即先存到队列中，会被先取出来）。Queue提供了一个基本的FIFO容器，使用方法很简单,maxsize是个整数，指明了队列中能存放的数据个数的上限。一旦达到上限，插入会导致阻塞，直到队列中的数据被消费掉。如果maxsize小于或者等于0，队列大小没有限制。

举例：

import queue

q = queue.Queue(maxsize=10) #设置队列只能存10个值

for i in range(3):
    q.put(i)

while not q.empty():  #判断队列是否为空，如果不为空，则依次取出
    print(q.get())
输出：
0
1
2
Process finished with exit code 0

B、LIFO队列
　　class queue.LifoQueue(maxsize=0) : LIFO即Last in First Out，后进先出(即后面写到队列的会先被取出)。与栈的类似，使用也很简单,maxsize用法同上。

举例：

import  queue
q = queue.LifoQueue(maxsize=10)#设置上限

for i in range(3):
    print(i) 
    q.put(i)
while q.not_empty: #判断队列如果不为空就取值
    print(q.get())
输出：
存到队列中的顺序：
0
1
2
从队列中取出的顺序
2
1
0

C、优先级队列
　　class queue.PriorityQueue(maxsize=0) ： 构造一个优先队列。maxsize用法同上。可以根据设置的队列优先取出。

 举例：

import queue

q = queue.PriorityQueue(maxsize=15)

q.put((2,"code"))
q.put((4,"chen"))
q.put((1,"chen123"))
q.put((6,"chen133"))

while q.not_empty:
    print(q.get())
输出：
(1, 'chen123')
(2, 'code')
(4, 'chen')
(6, 'chen123')

 注：按照数字的排列，从小到大排列取出。

D、其他各个功能的使用，参考例子，打开注释就可以认证

• class queue.put((2,"code")) #把数据写到队列中，如果超出maxsize值，put的时候进程就会被卡死。
• class queue.get() #从队列中取数据
• class queue.get_nowait() #这个函数当队列取完之后，以报错的方式提示已经提示queue.Empty，可以利用抛异常的方式抓取。
• class queue.qsize()#标注取数值的位置，如果为零说明已经取完
• class queue.full() #这个是提示队列是否已经存满
• class queue.join() #阻塞打印,阻止程序往下执行
• class queue.empty() #可以这个参数来判断队列是否消费完成
• class queue.task_done() #之前入队的一个任务已经完成。由队列的消费者线程调用。每一个get()调用得到一个任务，接下来的task_done()调用告诉队列该任务已经处理完毕。如果当前一个join()正在阻塞，它将在队列中的所有任务都处理完时恢复执行（即每一个由put()调用入队的任务都有一个对应的task_done()调用）。

举例：

import queue

q = queue.PriorityQueue(maxsize=6)

q.put((2,"code"))  #把数据写到队列中，如果超出maxsize值，put的时候进程就会被卡死。
q.put((4,"chen"))
q.put((1,"chen123"))
q.put((6,"chen133"))
q.put_nowait((7,"chen345")) #是根据maxsize定义可以存储的值大小，如果需要put的值在队列里面超出了值。就会报出queue.Full队列已经存满。
#不至于进程会卡死，如果使用queue.put,超出队列的值，就直接卡死。
while q.not_empty:
    print(q.get()) #从队列中取数据
    #print(q.get_nowait()) #这个函数当队列取完之后，以报错的方式提示已经提示queue.Empty，可以利用抛异常的方式抓取。
    #print(q.qsize())#标注取数值的位置，如果为零说明已经取完
    #print(q.full()) #这个是提示队列是否已经存满
    #print(q.task_done())
    #print(q.join())  #阻塞打印,阻止程序往下执行
    if q.empty() is True: #可以这个参数来判断队列是否消费完成
        print ("队列中的数值已经取完1")
输出：
(1, 'chen123')
(2, 'code')
(4, 'chen')
(6, 'chen133')
(7, 'chen345')
队列中的数值已经取完1

 

2、生产者与消费者模型

 　　生产者和消费者之间用中间类似一个队列一样的东西串起来。这个队列可以想像成一个存放产品的“仓库”，生产者只需要关心这个“仓库”，并不需要关心具体的消费者，对于生产者而言甚至都不知道有这些消费者存在。对于消费者而言他也不需要关心具体的生产者，到底有多少生产者也不是他关心的事情，他只要关心这个“仓库”中还有没有东西。这种模型是一种松耦合模型。简单来讲，以上的例子是单线程输入、输出。 实际环境中，要解决的是边写入，边读取发数据。

　　总结：解决程序解耦,较少的资源解决高并发的问题。如图：

举例：

单线程

import threading,queue

def producter():
    for i in range(10):
       q.put("馒头 %s " % i)

    print("开始等待馒头被人买走....")
    q.join()
    print("所有馒头被取完")

def consumer(name):
    while q.qsize()> 0:
       print ("%s 取到 " % name,q.get())
       q.task_done() #告知任务执行完成了

if __name__ == "__main__":
   q = queue.Queue()
   p = threading.Thread(target=producter,)
   p.start()
   T1 = consumer("chen123")
输出：
开始等待馒头被人买走....
chen123 取到  馒头 0 
chen123 取到  馒头 1 
chen123 取到  馒头 2 
chen123 取到  馒头 3 
chen123 取到  馒头 4 
chen123 取到  馒头 5 
chen123 取到  馒头 6 
chen123 取到  馒头 7 
chen123 取到  馒头 8 
chen123 取到  馒头 9 
所有馒头被取完

 多线程 (参考大王例子)

import time,random
import queue,threading
q = queue.Queue()
def Producer(name):
  count = 0
  while count <20:
    time.sleep(random.randrange(3))
    q.put(count)
    print('Producer %s has produced %s baozi..' %(name, count))
    count +=1
def Consumer(name):
  count = 0
  while count <20:
    time.sleep(random.randrange(4))
    if not q.empty():
        data = q.get()
        print(data)
        print('\033[32;1mConsumer %s has eat %s baozi...\033[0m' %(name, data))
    else:
        print("-----no baozi anymore----")
    count +=1
p1 = threading.Thread(target=Producer, args=('A',))
c1 = threading.Thread(target=Consumer, args=('B',))
p1.start()
c1.start()

=============================================================================================

广告插入：

复习之前的两例子：

#等待所有线程的执行结果，例子：
import  threading

def run(n):
    print("run thread %s " % n)

t_res = []

for i in range(10):
    t = threading.Thread(target=run,args=(i,))
    t.start()
    t_res.append(t)

for r in t_res:
    r.join()

#守护进程服务与非守护线程程。非守护线程就是主人的意思。例子：
import threading
for i in range(10):
    t = threading.Thread(target=run,args=(i,))
    t.setDaemon(True) #设置为守护线程
    t.start()
print("master is done.....")#主线程挂掉之后，守护线程也会跟着断掉。