Python数据结构与算法—优先级队列Queue

开发 后端 算法
queue库提供了一个适用于多线程编程的先进先出(FIFO)数据结构,可以用来在生产者与消费者线程之间安全地传递消息或其他数据。它会为调用者处理锁定,使多个线程可以安全而更容易地处理同一个Queue实例。Queue的大小可能受限,以限制内存使用或处理。

[[405132]]

前言

queue库提供了一个适用于多线程编程的先进先出(FIFO)数据结构,可以用来在生产者与消费者线程之间安全地传递消息或其他数据。

它会为调用者处理锁定,使多个线程可以安全而更容易地处理同一个Queue实例。Queue的大小可能受限,以限制内存使用或处理。

基本用法

Queue类实现了一个基本的先进先出容器。使用put()将元素增加到这个序列的一端,使用get()从另一端删除。具体代码如下所示:

  1. import queue 
  2.  
  3. q = queue.Queue() 
  4.  
  5. for i in range(1, 10): 
  6.     q.put(i) 
  7. while not q.empty(): 
  8.     print(q.get(), end="  "

 运行之后,效果如下:

这里我们依次添加1到10到队列中,因为先进先出,所以出来的顺序也与添加的顺序相同。

LIFO队列

既然有先进先出队列queue,那么数据结构中肯定也有后进先出的队列。后进先出的队列为:LifoQueue,示例如下:

  1. import queue 
  2.  
  3. q = queue.LifoQueue() 
  4.  
  5. for i in range(1, 10): 
  6.     q.put(i) 
  7. while not q.empty(): 
  8.     print(q.get(), end="  "

 运行之后,效果如下:

 

优先队列

在操作系统中,我们常常会根据优先级来处理任务,比如系统的优先级最高,我们肯定优先处理系统任务,然后才处理用户的任务。同样,queue库给我们提供了PriorityQueue来处理优先级的队列。

示例如下:

  1. import queue 
  2. import threading 
  3.  
  4. class Job: 
  5.     def __init__(self, priority, desc): 
  6.         self.priority = priority 
  7.         self.desc = desc 
  8.         print("New Job:"desc
  9.         return 
  10.  
  11.     def __eq__(self, other): 
  12.         try: 
  13.             return self.priority == other.priority 
  14.         except AttributeError: 
  15.             return NotImplemented 
  16.  
  17.     def __lt__(self, other): 
  18.         try: 
  19.             return self.priority > other.priority 
  20.         except AttributeError: 
  21.             return NotImplemented 
  22.  
  23. def process_Job(q): 
  24.     while True
  25.         next_job = q.get() 
  26.         print(next_job.desc
  27.         q.task_done() 
  28.  
  29. q = queue.PriorityQueue() 
  30.  
  31. q.put(Job(5, "Five Job")) 
  32. q.put(Job(15, "Fifteen Job")) 
  33. q.put(Job(1, "One Job")) 
  34.  
  35. workers = [ 
  36.     threading.Thread(target=process_Job, args=(q,)), 
  37.     threading.Thread(target=process_Job, args=(q,)), 
  38.  
  39. for work in workers: 
  40.     work.setDaemon(True
  41.     work.start() 
  42.  
  43. q.join() 

 运行之后,效果如下:

这里,我们默认数值越大优先级越高,可以看到15先执行,然后再是5,1任务。这个例子展现了有多个线程在处理任务时,要根据get()时队列中元素的优先级来处理。

 

责任编辑:姜华 来源: 今日头条
相关推荐

2020-10-17 11:14:19

数据结构与算法系列

2021-03-09 06:30:32

JAVA数据结构算法

2023-08-08 08:28:03

消息消费端Spring

2009-08-11 14:43:42

C#数据结构与算法

2023-04-14 08:07:20

数据结构算法搜索

2021-07-16 07:57:34

Python数据结构

2020-11-25 14:28:56

DelayedWork

2020-10-21 14:57:04

数据结构算法图形

2023-03-08 08:03:09

数据结构算法归并排序

2023-09-26 12:22:37

队列Python

2023-10-27 07:04:20

2012-08-14 09:38:29

WAN优化

2024-03-11 07:46:40

React优先级队列二叉堆

2023-09-25 12:23:18

Python

2023-03-10 08:07:39

数据结构算法计数排序

2023-03-02 08:15:13

2023-03-07 08:02:07

数据结构算法数列

2022-12-23 09:41:14

优先级反转

2023-04-27 09:13:20

排序算法数据结构

2024-03-18 00:00:03

RabbitMQ代码延迟队列
点赞
收藏

51CTO技术栈公众号