python队列Queue
Queue队列是线程安全的,实现了所有需要的锁原语,所以使用Queue进行多线程同步就可以不用考虑资源锁的问题。
Queue实现了三种类型的队列
- FIFO队列(先进先出),第一个加入队列的对象被第一个取出,举个例子:
from queue import Queue
q=Queue(maxsize=0)#构造一个FIFO队列,maxsize设置队列大小的上界, 如果插入数据时, 达到上界会发生阻塞, 直到队列可以放入数据. 当maxsize小于或者等于0, 表示不限制队列的大小(默认)
for i in range(5):
q.put(i)
while not q.empty():
print(q.get())
输出:
0
1
2
3
4
- LIFO队列(后进先出),最后加入队列的对象被第一个取出,类似栈,总是从栈顶取出,举个例子:
from queue import Queue,LifoQueue,PriorityQueue
q=LifoQueue(maxsize=0)#构造一个LIFO队列,maxsize设置队列大小的上界, 如果插入数据时, 达到上界会发生阻塞, 直到队列可以放入数据. 当maxsize小于或者等于0, 表示不限制队列的大小(默认)
for i in range(5):
q.put(i)
while not q.empty():
print(q.get()
输出:
4
3
2
1
0
- PriorityQueue队列(优先级),保持队列数据有序,最小值被先取出(可以重写数据类型和排序规则的,这里不深究),举个例子:
from queue import Queue,LifoQueue,PriorityQueue
q=PriorityQueue(maxsize=0)#构造一个优先级队列,maxsize设置队列大小的上界, 如果插入数据时, 达到上界会发生阻塞, 直到队列可以放入数据. 当maxsize小于或者等于0, 表示不限制队列的大小(默认)
q.put(8)
q.put(6)
q.put(1)
q.put(5)
while not q.empty():
print(q.get())
输出:
1
5
6
8
三种队列对象提供的公共方法
Queue.empty() #如果队列为空, 返回True(注意队列为空时, 并不能保证调用put()不会阻塞); 队列不空返回False(不空时, 不能保证调用get()不会阻塞)
Queue.full() #如果队列为满, 返回True(不能保证调用get()不会阻塞), 如果队列不满, 返回False(并不能保证调用put()不会阻塞)
Queue.put(item[, block[, timeout]]) #向队列中放入元素, 如果可选参数block为True并且timeout参数为None(默认), 为阻塞型put(). 如果timeout是正数, 会阻塞timeout时间并引发Queue.Full异常. 如果block为False为非阻塞put
Queue.put_nowait(item) #等价于put(itme, False)
Queue.get([block[, timeout]]) #移除列队元素并将元素返回, block = True为阻塞函数, block = False为非阻塞函数. 可能返回Queue.Empty异常
Queue.get_nowait() #等价于get(False)
Queue.task_done() #在完成一项工作之后,Queue.task_done()函数向任务已经完成的队列发送一个信号
Queue.join() #实际上意味着等到队列为空,再执行别的操作
官方文档给出的多线程模型
def worker():
while True:
item = q.get()
do_work(item)
q.task_done()
q = Queue()
for i in range(num_worker_threads):
t = Thread(target=worker)
t.daemon = True
t.start()
for item in source():
q.put(item)
q.join() # block until all tasks are done
线程同步:生产者-消费者模型
from queue import Queue
import random
import threading
import time
# Producer thread
class Producer(threading.Thread):
def __init__(self, t_name, queue):
threading.Thread.__init__(self, name=t_name)
self.data = queue
def run(self):
for i in range(5):
print("%s: %s is producing %d to the queue!" % (time.ctime(), self.getName(), i))
self.data.put(i)
time.sleep(random.randrange(10) / 5)
print("%s: %s finished!" % (time.ctime(), self.getName()))
# Consumer thread
class Consumer(threading.Thread):
def __init__(self, t_name, queue):
threading.Thread.__init__(self, name=t_name)
self.data = queue
def run(self):
for i in range(5):
val = self.data.get()
print("%s: %s is consuming. %d in the queue is consumed!" % (time.ctime(), self.getName(), val))
time.sleep(random.randrange(10))
print("%s: %s finished!" % (time.ctime(), self.getName()))
# Main thread
def main():
queue = Queue()
producer = Producer('Pro.', queue)
consumer = Consumer('Con.', queue)
producer.start()
consumer.start()
producer.join()
consumer.join()
print('All threads terminate!')
if __name__ == '__main__':
main()
运行结果:
Mon Jul 29 11:52:57 2019: Pro. is producing 0 to the queue!
Mon Jul 29 11:52:57 2019: Con. is consuming. 0 in the queue is consumed!
Mon Jul 29 11:52:58 2019: Pro. is producing 1 to the queue!
Mon Jul 29 11:52:59 2019: Pro. is producing 2 to the queue!
Mon Jul 29 11:52:59 2019: Pro. is producing 3 to the queue!
Mon Jul 29 11:52:59 2019: Pro. is producing 4 to the queue!
Mon Jul 29 11:53:01 2019: Pro. finished!
Mon Jul 29 11:53:04 2019: Con. is consuming. 1 in the queue is consumed!
Mon Jul 29 11:53:10 2019: Con. is consuming. 2 in the queue is consumed!
Mon Jul 29 11:53:19 2019: Con. is consuming. 3 in the queue is consumed!
Mon Jul 29 11:53:25 2019: Con. is consuming. 4 in the queue is consumed!
Mon Jul 29 11:53:31 2019: Con. finished!
All threads terminate!