排好队，一个一个来：宫本武藏教你学队列（附各种队列源码）

前言：

哈喽！欢迎来到黑洞晓威的博客！

上一次我们在这里聊了一下队列，现在，让我们再次翻开这个话题，继续探讨一下这个有趣的数据结构吧！
虽然队列看起来比较普通，但是它在实际应用中却 有着不可替代的作用。所以，无论是计算机系统中的任务调度，还是网络数据包的传输，队列都扮演着重要的角色。
接下来，我们将深入了解队列的应用、实现以及相关算法问题。让我们一起来暴打队列吧！

理解“队列”的正确姿势

王者荣耀中宫本武藏有这么一句台词——“想挑战的人排好队，一个一个来”。
这句台词可以很好地联系到数据结构中的队列。在数据结构中，队列就像是一群人在排队等待挑战宫本武藏，每个人都必须按照先来后到的原则，依次接受服务。当新的人加入队伍时，必须排在队尾，而队伍中的人只能按照先后顺序依次出队。

我们知道，栈只支持两个基本操作： 入栈push()和出栈pop()。队列跟栈非常相似，支持的操作也很有限，最基本的操作也是两个： 入队enqueue()，放一个数据到队列尾部； 出队dequeue()，从队列头部取一个元素。

所以，队列跟栈一样，也是一种 操作受限的线性表数据结构。

队列的概念很好理解，基本操作也很容易掌握。作为一种非常基础的数据结构，队列的应用也非常广泛，比如排队、缓存、广度优先搜索等等。你准备好了吗？让我们一起来探索队列的奥秘吧！

一个关于队列的小思考——请求处理

我们知道，CPU资源是有限的，任务的处理速度与线程个数并不是线性正相关。相反，过多的线程反而会导致CPU频繁切换，处理性能下降。所以，线程池的大小一般都是综合考虑要处理任务的特点和硬件环境，来事先设置的。

当我们向固定大小的线程池中请求一个线程时，如果线程池中没有空闲资源了，这个时候线程池如何处理这个请求？是拒绝请求还是排队请求？各种处理策略又是怎么实现的呢？

实际上，这些问题并不复杂，其底层的数据结构就是我们今天要学的内容，队列（queue）。

队列的两大“护法”————顺序队列和链式队列

嘿，大佬们！我们现在知道了，队列跟栈一样，也是一种抽象的数据结构。它的特性很简单，就是先进先出，支持在队尾插入元素，在队头删除元素。但是，究竟

该如何实现一个队列呢？

让我们来看看吧！就像栈一样，队列也可以用数组来实现，这种实现方式叫做顺序队列。还可以用链表来实现，这种实现方式叫做链式队列。顺序队列和链式队列都有各自的优缺点，需要根据实际情况进行选择。所以，无论是顺序队列还是链式队列，都是我们实现队列的可选方案。现在，让我们先来看下基于数组的实现方法吧！

数组实现的队列

// 用数组实现的队列
public class ArrayQueue {
  // 数组：items，数组大小：n
  private String[] items;
  private int n = 0;
  // head表示队头下标，tail表示队尾下标
  private int head = 0;
  private int tail = 0;

  // 申请一个大小为capacity的数组
  public ArrayQueue(int capacity) {
    items = new String[capacity];
    n = capacity;
  }

  // 入队
  public boolean enqueue(String item) {
    // 如果tail == n 表示队列已经满了
    if (tail == n) return false;
    items[tail] = item;
    ++tail;
    return true;
  }

  // 出队
  public String dequeue() {
    // 如果head == tail 表示队列为空
    if (head == tail) return null;
    // 为了让其他语言的同学看的更加明确，把--操作放到单独一行来写了
    String ret = items[head];
    ++head;
    return ret;
  }
}

比起栈的数组实现，队列的数组实现稍微有点儿复杂，但是没关系。我稍微解释一下实现思路，你很容易就能明白了。

对于栈来说，我们只需要一个 栈顶指针 就可以了。但是队列需要两个指针：一个是head指针，指向队头；一个是tail指针，指向队尾。

你可以结合下面这张图来理解。当a、b、c、d依次入队之后，队列中的head指针指向下标为0的位置，tail指针指向下标为4的位置。

当我们调用两次出队操作之后，队列中head指针指向下标为2的位置，tail指针仍然指向下标为4的位置。

你肯定已经发现了，随着不停地进行入队、出队操作，head和tail都会持续往后移动。当tail移动到最右边，即使数组中还有空闲空间，也无法继续往队列中添加数据了。这个问题该如何解决呢？

你是否还记得，在数组那一节，我们也遇到过类似的问题，就是数组的删除操作会导致数组中的数据不连续。你还记得我们当时是怎么解决的吗？对，用 数据搬移！但是，每次进行出队操作都相当于删除数组下标为0的数据，要搬移整个队列中的数据，这样出队操作的时间复杂度就会从原来的O(1)变为O(n)。能不能优化一下呢？

实际上，我们在出队时可以不用搬移数据。如果没有空闲空间了，我们只需要在入队时，再集中触发一次数据的搬移操作。借助这个思想，出队函数dequeue()保持不变，我们稍加改造一下入队函数enqueue()的实现，就可以轻松解决刚才的问题了。下面是具体的代码：

   // 入队操作，将item放入队尾
  public boolean enqueue(String item) {
    // tail == n表示队列末尾没有空间了
    if (tail == n) {
      // tail ==n && head==0，表示整个队列都占满了
      if (head == 0) return false;
      // 数据搬移
      for (int i = head; i < tail; ++i) {
        items[i-head] = items[i];
      }
      // 搬移完之后重新更新head和tail
      tail -= head;
      head = 0;
    }

    items[tail] = item;
    ++tail;
    return true;
  }

从代码中我们看到，当队列的tail指针移动到数组的最右边后，如果有新的数据入队，我们可以将head到tail之间的数据，整体搬移到数组中0到tail-head的位置。

这种实现思路中，出队操作的时间复杂度仍然是O(1)，但入队操作的时间复杂度还是O(1)吗？你可以用我们第3节、第4节讲的算法复杂度分析方法，自己试着分析一下。

接下来，我们再来看下 基于链表的队列实现方法。

链表实现的队列

基于链表的实现，我们同样需要两个指针：head指针和tail指针。它们分别指向链表的第一个结点和最后一个结点。如图所示，入队时，tail->next= new_node, tail = tail->next；出队时，head = head->next。我将具体的代码放到GitHub上，你可以自己试着实现一下，然后再去GitHub上跟我实现的代码对比下，看写得对不对。

首先，我们需要定义一个节点类，它包含一个值属性和一个指向下一个节点的指针属性：

public class Node<T> { // 这是一个泛型类，T表示节点的值可以是任何类型
    T value; // 存储节点的值
    Node<T> next; // 指向下一个节点的指针
    
    public Node(T value) { // 构造函数，用来创建新的节点
        this.value = value; // 设置节点的值
        this.next = null; // 初始时，指针为空
    }
}

接下来，我们定义一个队列类，它包含一个指向队列头部的指针属性和一个指向队列尾部的指针属性：

public class Queue<T> { // 这是一个泛型类，T表示队列的元素可以是任何类型
    Node<T> head; // 指向队列头部的指针
    Node<T> tail; // 指向队列尾部的指针
    
    public Queue() { // 构造函数，用来创建新的队列
        this.head = null; // 初始时，头部指针为空
        this.tail = null; // 初始时，尾部指针为空
    }
}

在队列类中，我们可以实现以下方法：

1. enqueue(value)：将一个元素添加到队列的尾部。

public void enqueue(T value) { // 将元素value添加到队列的尾部
    Node<T> newNode = new Node<>(value); // 创建一个新的节点
    if (tail == null) { // 如果队列为空
        head = newNode; // 将头部指针指向新节点
        tail = newNode; // 将尾部指针指向新节点
    } else { // 如果队列不为空
        tail.next = newNode; // 将当前尾部节点的指针指向新节点
        tail = newNode; // 将尾部指针指向新节点
    }
}

2. dequeue()：从队列的头部移除并返回一个元素。

public T dequeue() { // 从队列的头部移除并返回一个元素
    if (head == null) { // 如果队列为空
        return null; // 返回null
    }
    T value = head.value; // 获取队列头部节点的值
    head = head.next; // 将头部指针指向下一个节点
    if (head == null) { // 如果队列为空
        tail = null; // 将尾部指针也置为空
    }
    return value; // 返回队列头部节点的值
}

3. peek()：返回队列头部的元素，但不移除它。

public T peek() { // 返回队列头部的元素，但不移除它
    if (head == null) { // 如果队列为空
    return null; // 返回null
	}
 return head.value; // 返回队列头部节点的值
}

4. isEmpty()：检查队列是否为空。

public boolean isEmpty() { // 检查队列是否为空
    return head == null; // 如果头部指针为空，队列为空
}

5. clear()：清空队列。

public void clear() { // 清空队列
    head = null; // 将头部指针置为空
    tail = null; // 将尾部指针置为空
}

在这里偷偷告诉大家，基于链表的队列我懒得写了于是就交给了ChatGPT完成，说实话效果竟然出奇的好，大家在学习这些基础内容的时候也不妨善用ChatGPT，说必定你就能解锁一个优质的老师哈哈哈。

循环队列

我们刚才用数组来实现队列的时候，在tail==n时，会有数据搬移操作，这样入队操作性能就会受到影响。那有没有办法能够避免数据搬移呢？我们来看看循环队列的解决思路。

循环队列，顾名思义，它长得像一个环。原本数组是有头有尾的，是一条直线。现在我们把首尾相连，扳成了一个环。我画了一张图，你可以直观地感受一下。

我们可以发现，图中这个队列的大小为8，当前head=4，tail=7。当有一个新的元素a入队时，我们放入下标为7的位置。但这个时候，我们并不把tail更新为8，而是将其在环中后移一位，到下标为0的位置。当再有一个元素b入队时，我们将b放入下标为0的位置，然后tail加1更新为1。所以，在a，b依次入队之后，循环队列中的元素就变成了下面的样子：

通过这样的方法，我们成功避免了数据搬移操作。看起来不难理解，但是循环队列的代码实现难度要比前面讲的非循环队列难多了。要想写出没有bug的循环队列的实现代码，我个人觉得，最关键的是， 确定好队空和队满的判定条件。

在用数组实现的非循环队列中，队满的判断条件是tail == n，队空的判断条件是head == tail。那针对循环队列，如何判断队空和队满呢？

队列为空的判断条件仍然是head == tail。但队列满的判断条件就稍微有点复杂了。我画了一张队列满的图，你可以看一下，试着总结一下规律。

就像我图中画的队满的情况，tail=3，head=4，n=8，所以总结一下规律就是：(3+1)%8=4。多画几张队满的图，你就会发现，当队满时， (tail+1)%n=head。

你有没有发现，当队列满时，图中的tail指向的位置实际上是没有存储数据的。所以，循环队列会浪费一个数组的存储空间。

Talk is cheap，如果还是没怎么理解，那就show you code吧。

public class CircularQueue {
  // 数组：items，数组大小：n
  private String[] items;
  private int n = 0;
  // head表示队头下标，tail表示队尾下标
  private int head = 0;
  private int tail = 0;

  // 申请一个大小为capacity的数组
  public CircularQueue(int capacity) {
    items = new String[capacity];
    n = capacity;
  }

  // 入队
  public boolean enqueue(String item) {
    // 队列满了
    if ((tail + 1) % n == head) return false;
    items[tail] = item;
    tail = (tail + 1) % n;
    return true;
  }

  // 出队
  public String dequeue() {
    // 如果head == tail 表示队列为空
    if (head == tail) return null;
    String ret = items[head];
    head = (head + 1) % n;
    return ret;
  }
}

关于开篇，你明白了吗？

队列的知识就讲完了，我们现在回过来看下开篇的问题。线程池没有空闲线程时，新的任务请求线程资源时，线程池该如何处理？各种处理策略又是如何实现的呢？

我们一般有两种处理策略。

第一种是非阻塞的处理方式，直接拒绝任务请求；

另一种是阻塞的处理方式，将请求排队，等到有空闲线程时，取出排队的请求继续处理。那如何存储排队的请求呢？

我们希望公平地处理每个排队的请求，先进者先服务，所以队列这种数据结构很适合来存储排队请求。我们前面说过，队列有基于链表和基于数组这两种实现方式。这两种实现方式对于排队请求又有什么区别呢？

基于链表的实现方式，可以实现一个支持无限排队的无界队列（unbounded queue），但是可能会导致过多的请求排队等待，请求处理的响应时间过长。所以，针对响应时间比较敏感的系统，基于链表实现的无限排队的线程池是不合适的。

而基于数组实现的有界队列（bounded queue），队列的大小有限，所以线程池中排队的请求超过队列大小时，接下来的请求就会被拒绝，这种方式对响应时间敏感的系统来说，就相对更加合理。
不过，设置一个合理的队列大小，也是非常有讲究的。队列太大导致等待的请求太多，队列太小会导致无法充分利用系统资源、发挥最大性能。

最后说一句

感谢大家的阅读，文章通过网络学习资源以及自己的学习过程整理出来，希望能帮助到大家。

才疏学浅，难免会有纰漏，如果你发现了错误的地方，可以提出来，我会对其加以修改。