多线程利器－－－队列(queue)

时间：2023-03-10 03:11:31
多线程利器－－－队列(queue)

列表是不安全的数据结构

import threading,time

li=[1,2,3,4,5]

def pri():

    while li:

        a=li[-1]

        print(a)

        time.sleep(1)

        try:

            li.remove(a)

        except Exception as e:

            print('----',a,e)

t1=threading.Thread(target=pri,args=())

t1.start()

t2=threading.Thread(target=pri,args=())

t2.start()

思考：如何通过对列来完成上述功能？

queue is especially useful in threaded programming when information must be exchanged safely between multiple threads.

queue列队类的方法

创建一个“队列”对象

import Queue

q = Queue.Queue(maxsize = 10)

Queue.Queue类即是一个队列的同步实现。队列长度可为无限或者有限。可通过Queue的构造函数的可选参数maxsize来设定队列长度。如果maxsize小于1就表示队列长度无限。

将一个值放入队列中

q.put(10)

调用队列对象的put()方法在队尾插入一个项目。put()有两个参数，第一个item为必需的，为插入项目的值；第二个block为可选参数，默认为

1。如果队列当前为空且block为1，put()方法就使调用线程暂停,直到空出一个数据单元。如果block为0，put方法将引发Full异常。

将一个值从队列中取出

q.get()

调用队列对象的get()方法从队头删除并返回一个项目。可选参数为block，默认为True。如果队列为空且block为True，
get()就使调用线程暂停，直至有项目可用。如果队列为空且block为False，队列将引发Empty异常。

Python Queue模块有三种队列及构造函数:

1、Python Queue模块的FIFO队列先进先出。   class queue.Queue(maxsize)

2、LIFO类似于堆，即先进后出。               class queue.LifoQueue(maxsize)

3、还有一种是优先级队列级别越低越先出来。        class queue.PriorityQueue(maxsize)

此包中的常用方法(q = Queue.Queue()):

q.qsize() 返回队列的大小

q.empty() 如果队列为空，返回True,反之False

q.full() 如果队列满了，返回True,反之False

q.full 与 maxsize 大小对应

q.get([block[, timeout]]) 获取队列，timeout等待时间

q.get_nowait() 相当q.get(False)

非阻塞 q.put(item) 写入队列，timeout等待时间

q.put_nowait(item) 相当q.put(item, False)

q.task_done() 在完成一项工作之后，q.task_done() 函数向任务已经完成的队列发送一个信号

q.join() 实际上意味着等到队列为空，再执行别的操作

other mode:

import queue

#先进后出

q=queue.LifoQueue()

q.put(34)

q.put(56)

q.put(12)

#优先级

# q=queue.PriorityQueue()

# q.put([5,100])

# q.put([7,200])

# q.put([3,"hello"])

# q.put([4,{"name":"alex"}])

while 1:

  data=q.get()

  print(data)

生产者消费者模型：

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

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

什么是生产者消费者模式

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

这就像，在餐厅，厨师做好菜，不需要直接和客户交流，而是交给前台，而客户去饭菜也不需要不找厨师，直接去前台领取即可，这也是一个结耦的过程。

import time,random

import queue,threading

q = queue.Queue()

def Producer(name):

  count = 0

  while count <10:

    print("making........")

    time.sleep(random.randrange(3))

    q.put(count)

    print('Producer %s has produced %s baozi..' %(name, count))

    count +=1

    #q.task_done()

    #q.join()

    print("ok......")

def Consumer(name):

  count = 0

  while count <10:

    time.sleep(random.randrange(4))

    if not q.empty():

        data = q.get()

        #q.task_done()

        #q.join()

        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',))

# c2 = threading.Thread(target=Consumer, args=('C',))

# c3 = threading.Thread(target=Consumer, args=('D',))

p1.start()

c1.start()

# c2.start()

# c3.start()

相关文章