java数据结构之（二）：Queue简介

最新推荐文章于 2024-07-27 22:27:32 发布

dalianlv

最新推荐文章于 2024-07-27 22:27:32 发布

阅读量323

点赞数

分类专栏：数据结构文章标签：数据结构队列 queue

本文链接：https://blog.csdn.net/maofenghua/article/details/78589502

版权

数据结构专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1.什么是队列

队列是一种特殊的线性表，它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。

在队列这种数据结构中，最先插入的元素将是最先被删除的元素；反之最后插入的元素将是最后被删除的元素，因此队列又称为“先进先出”（FIFO—first in first out）的线性表。

2.队列常用的方法

(1).add：增加一个元索，如果队列已满，则抛出一个IIIegaISlabEepeplian异常；

(2).remove：移除并返回队列头部的元素 ,如果队列为空，则抛出一个NoSuchElementException异常；

(3).element:返回队列头部的元素,如果队列为空，则抛出一个NoSuchElementException异常；

(4).offer:添加一个元素并返回true，如果队列已满，则返回false；

(5).poll:移除并返问队列头部的元素,如果队列为空，则返回null；

(6).peek:返回队列头部的元素, 如果队列为空，则返回null；

(7).put:添加一个元素，如果队列满，则阻塞；

(8).take：移除并返回队列头部的元素，如果队列为空，则阻塞；

3.队列（Queue）的类关系图

4.PriorityQueue（优先队列）

优先级队列是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。如果不提供Comparator的话，优先队列中元素默认按自然顺序排列，也就是数字默认是小的在队列头，字符串则按字典序排列。

5.BlockingQueue（阻塞队列）

BlockingQueue，顾名思义，阻塞队列。BlockingQueue是在java.util.concurrent下的，因此不难理解，BlockingQueue是为了解决多线程中数据高效安全传输而提出的。

多线程中，很多场景都可以使用队列实现，比如经典的生产者/消费者模型，通过队列可以便利地实现两者之间数据的共享，定义一个生产者线程，定义一个消费者线程，通过队列共享数据就可以了。

当然现实不可能都是理想的，比如消费者消费速度比生产者生产的速度要快，那么消费者消费到一定程度上的时候，必须要暂停等待一下了（使消费者线程处于WAITING状态）。BlockingQueue的提出，就是为了解决这个问题的，他不用程序员去控制这些细节，同时还要兼顾效率和线程安全。

阻塞队列所谓的"阻塞"，指的是某些情况下线程会挂起（即阻塞），一旦条件满足，被挂起的线程又会自动唤醒。使用BlockingQueue，不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，这些内容BlockingQueue都已经做好了。

6.常见的BlockingQueue介绍

(1).ArrayBlockingQueue: 基于数组的阻塞队列，必须指定队列大小。比较简单。ArrayBlockingQueue中只有一个ReentrantLock对象，这意味着生产者和消费者无法并行运行（见下面的代码）。另外，创建ArrayBlockingQueue时，可以指定ReentrantLock是否为公平锁，默认采用非公平锁。

(2).LinkedBlockingQueue: 基于链表的阻塞队列，和ArrayBlockingQueue差不多。不过LinkedBlockingQueue如果不指定队列容量大小，会默认一个类似无限大小的容量，之所以说是类似是因为这个无限大小是Integer.MAX_VALUE，这么说就好理解ArrayBlockingQueue 为什么必须要制定大小了，如果ArrayBlockingQueue不指定大小的话就用Integer.MAX_VALUE，那将造成大量的空间浪费，但是基于链表实现就不一样的，一个一个节点连起来而已。另外，LinkedBlockingQueue生产者和消费者都有自己的锁（见下面的代码），这意味着生产者和消费者可以"同时"运行。

(3).PriorityBlockingQueue: PriorityBlockingQueue是一个没有边界的队列，它的排序规则和 java.util.PriorityQueue一样。需要注意，PriorityBlockingQueue中允许插入null对象。

(4).SynchronousQueue: 一种没有缓冲的等待队列。每一个插入操作必须等待一个线程对应的移除操作。SynchronousQueue又有两种模式：公平模式和非公平模式。

(5).DelayQueue:延迟型阻塞队列。

DelayQueue是一个BlockingQueue，其特化的参数是Delayed。Delayed扩展了Comparable接口，比较的基准为延时的时间值，Delayed接口的实现类getDelay的返回值应为固定值（final）。DelayQueue内部是使用PriorityQueue实现的。
简单来说：
DelayQueue = BlockingQueue + PriorityQueue + Delayed
DelayQueue是一个使用优先队列（PriorityQueue）实现的BlockingQueue，优先队列的比较基准值是时间。

7.DelayQueue适合使用的一些实际开发场景

(1).关闭空闲连接。服务器中，有很多客户端的连接，空闲一段时间之后需要关闭之。
(2).缓存。缓存中的对象，超过了空闲时间，需要从缓存中移出。
(3).任务超时处理。在网络协议滑动窗口请求应答式交互时，处理超时未响应的请求。

8.PriorityQueue代码示例

package com.biyao.current.priorityqueue;
/**
 * @ClassName: Student
 * @Description: 学生类实体
 * @author yangy
 * @date 2017年11月14日 下午3:04:41
 */
public class Student {
	
	private int id;
	
	private String name;
	
	public Student(int id,String name){
		this.id = id;
		this.name = name;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
}

package com.biyao.current.priorityqueue;

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;

/**
 * @ClassName: PriorityQueueExample
 * @Description: 优先队列测试类
 * @author yangy
 * @date 2017年11月14日 下午3:13:20
 */
public class PriorityQueueExample {
	
	public static void main(String[] args) {
		
		//优先队列自然排序示例
        Queue<Integer> integerPriorityQueue = new PriorityQueue<Integer>(7);
        Random rand = new Random();
        for(int i=0;i<7;i++){
            integerPriorityQueue.add(new Integer(rand.nextInt(100)));
        }
        for(int i=0;i<7;i++){
            Integer in = integerPriorityQueue.poll();
            System.out.println("Processing Integer:"+in);
        }
        
      //Comparator实现
       Comparator<Student> idComparator = new Comparator<Student>(){
	        @Override
	        public int compare(Student c1, Student c2) {
	            return (int) (c1.getId() - c2.getId());
	        }
        };
        
        Queue<Student> studentPriorityQueue = new PriorityQueue<Student>(7,idComparator);
        for(int i=0; i<7; i++){
            int id = rand.nextInt(100);
            studentPriorityQueue.add(new Student(id, "yangy "+id + "号"));
        }
        
        while(true){
        	Student student = studentPriorityQueue.poll();
            if(student == null){
            	break;
            }
            System.out.println("学生信息：【id="+student.getId()+",name="+student.getName()+"】");
        }
		
	}
	
}

运行效果图：

9.DelayQueue代码示例

package com.biyao.current.delayqueue2;

import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * @ClassName: Student
 * @Description: 学生实体类
 * @author yangy
 * @date 2017年11月17日 下午1:10:57
 */
public class Student implements Runnable,Delayed{
	
	  private String name;  //姓名
	  private long costTime;//做试题的时间
	  private long finishedTime;//完成时间

	  public Student(String name, long costTime) {
	         this. name = name;
	         this. costTime= costTime;
	         finishedTime = costTime + System. currentTimeMillis();
	  }

	  @Override
	  public void run() {
	        System. out.println( name + " 交卷,用时" + costTime /1000 + "s");
	  }

	  @Override
	  public long getDelay(TimeUnit unit) {
	         return ( finishedTime - System.currentTimeMillis());
	  }

	  @Override
	  public int compareTo(Delayed o) {
	        Student other = (Student) o;
	         return costTime >= other. costTime?1:-1;
	  }
}

package com.biyao.current.delayqueue2;

import java.util.Random;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @ClassName: Teacher
 * @Description: 老师实体类
 * @author yangy
 * @date 2017年11月17日 下午1:12:48
 */
public class Teacher {
	
	  static final int STUDENT_SIZE = 30;
	  public static void main(String[] args) throws InterruptedException {
	        Random r = new Random();
	        //把所有学生看做一个延迟队列
	        DelayQueue<Student> students = new DelayQueue<Student>();
	        
	        students.put( new Student( "学生-yangy", 10000));
	        Student student = students.take();
	        student.run();
	        
	        //构造一个线程池用来让学生们“做作业”
	        ExecutorService exec = Executors.newFixedThreadPool(STUDENT_SIZE);
	         for ( int i = 0; i < STUDENT_SIZE; i++) {
               //初始化学生的姓名和做题时间
               students.put( new Student( "学生" + (i + 1), 3000 + r.nextInt(10000)));
	        }
	        //开始做题
	        while(! students.isEmpty()){
	           exec.execute( students.take());
	        }
	        exec.shutdown();
	        
	  }
}

运行效果图：