Python queue队列

 

作用:

 

那么些阻塞队列正是⽤来给⽣产者和顾客解耦的。纵观⼤多数设计情势,都会找⼀个不熟悉人出来进⾏解耦

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

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

PriorityQueue:优先队列,级别越低,越优先
deque:双边队列


导入三种队列,包

from queue import Queue,LifoQueue,PriorityQueue

 

参数介绍:

Python的Queue模块中提供了一块儿的、线程安全的行列类,包蕴FIFO(先⼊先出)队列Queue,LIFO(后⼊先出)队列LifoQueue,和优先级队列PriorityQueue。那些队列都达成了锁原语(能够通晓为原⼦操作,即要么不做,要么就做完),能够在十二线程中一向使⽤。能够使⽤队列来完毕线程间的一块。

   解耦:使程序间接完成松耦合,修改1个函数,不会有串联关系。

参数介绍:

import threading,time
import queue

# 最多存入10个
q = queue.Queue(maxsize=10)

def producer(name):
    count = 1

    while True:

           # 生产一块骨头
            q.put("骨头 %s" % count )
            print("生产了骨头",count)
            count +=1
            time.sleep(0.3)

def consumer(name):
    while True:
        print("%s 取到[%s] 并且吃了它" %(name, q.get()))
        time.sleep(1)

       # 告知这个任务执行完了
        q.task_done() 

# 生成线程
p = threading.Thread(target=producer,args=("德国骨科",))
c = threading.Thread(target=consumer,args=("陈狗二",))
d = threading.Thread(target=consumer,args=("吕特黑",))

# 执行线程
p.start()
c.start()
d.start()

⽣产者消费者方式的辨证:

   进步处理作用:FIFO = 现进先出,LIFO = 后入先出。

 

  队列能够出现的派八个线程,对排列的线程处理,并切每种必要处理线程只需要将呼吁的数额放入队列容器的内部存款和储蓄器中,线程不须要拭目以俟,当排列完结处理完数据后,线程在按时来取多少即可。请求数据的线程只与这几个行列容器存在涉嫌,处理数量的线程down掉不会潜移默化到请求数据的线程,队列会派给其余线程处理那分多少,它完成领会耦,进步作用。队列内会有三个有各样的器皿,列表与那几个容器是有分别的,列表中多少固然是排列的,但数量被取走后还会保留,而队列中这几个容器的数据被取后将不会保留。当必须在八个线程之间安全地交换音讯时,队列在线程编制程序中特意有用。

单抽象出生产者和买主,还够不上是生产者/消费者情势。该模还亟需有1个缓冲区处于生产者和消费者之间,作为5个中介。生产者把数量放入缓冲区,而顾客从缓冲区取出数据。

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

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

#输出队列所有数据
print(dq)
#移除队尾,并返回
print(dq.pop())
#移除队左,并返回
print(dq.popleft())
#输出:
deque(['d', 'a', 'b', 'c'])
c
d
# 先入先出 maxsize 可设置大小,设置block=False抛异常
class queue.Queue(maxsize=0)  

 # 后进先出 
class queue.LifoQueue(maxsize=0)

# 存储数据时可设置优先级的队列
# 优先级设置数越小等级越高
class queue.PriorityQueue(maxsize=0) 

# 放入数据
Queue.put(item, block=True, timeout=None)

# 取出数据 #没有数据将会等待
Queue.get(block=True, timeout=None)

# 如果1秒后没取到数据就退出
Queue.get(timeout = 1)


# 取数据,如果没数据抛queue.Empty异常
Queue.get_nowait()

# 查看队列大小
Queue.qsize()

# 返回True,如果空
Queue.empty() #return True if empty  

# 设置队列大小
Queue.full() 

# 后续调用告诉队列,任务的处理是完整的。
Queue.task_done()

 

在线程世界⾥,⽣产者正是⽣产数据的线程,消费者就是消费数量的线程。在102线程开发在那之中,尽管⽣产者处理速度极快,⽽消费者处理速度相当的慢,那么⽣产者就无法不等待顾客处理完,才能持续⽣产数据。同样的道理,即便顾客的处理能⼒⼤于⽣产者,那么消费者就务须等待⽣产者。为了消除那么些难点于是引⼊了⽣产者和消费者情势。

365bet亚洲真人, 

   进步处理功能:FIFO = 现进先出,LIFO = 后入先出。

作用:

在实质上的软件开发进度中,经常会遇上如下场景:有些模块负责发生多少,那个数据由另1个模块来担负处理(此处的模块是广义的,能够是类、函数、线程、进度等)。产⽣数据的模块,就形象地称呼生产者;⽽而拍卖数量的模块,就称为消费者。

 

import threading,time
import queue

# 最多存入10个
q = queue.Queue(maxsize=10)

def producer(name):
    count = 1

    while True:

           # 生产一块骨头
            q.put("骨头 %s" % count )
            print("生产了骨头",count)
            count +=1
            time.sleep(0.3)

def consumer(name):
    while True:
        print("%s 取到[%s] 并且吃了它" %(name, q.get()))
        time.sleep(1)

       # 告知这个任务执行完了
        q.task_done() 

# 生成线程
p = threading.Thread(target=producer,args=("德国骨科",))
c = threading.Thread(target=consumer,args=("陈狗二",))
d = threading.Thread(target=consumer,args=("吕特黑",))

# 执行线程
p.start()
c.start()
d.start()

 

⽣产者消费者方式是经过⼀个容器来消除⽣产者和买主的强耦合难题。⽣产者和买主互相之间不直接通信,⽽通过阻塞队列来进⾏通信,所以⽣产者⽣产完数据现在不⽤等待买主处理,直接扔给卡住队列,消费者不找⽣产者要多少,⽽是直接从绿灯队列⾥取,阻塞队列就一定于⼀个缓冲区,平衡了⽣产者和买主的拍卖能⼒。

生产消费模型:

   解耦:使程序直接达成松耦合,修改一个函数,不会有串联关系。

   进步处理功用:FIFO = 现进先出,LIFO = 后入先出。

发表评论

电子邮件地址不会被公开。 必填项已用*标注