文章来源于极客时间前google工程师−王争专栏。

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

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

如何理解队列

队列这个概念非常好理解。你可以把它想象成排队买票，先来的先买，后来的人只能站末尾，不允许插队。先进者先出，这就是典型的“队列”。

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

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

队列的应用：

• 循环队列
• 阻塞队列
• 并发队列

它们在很多偏底层系统、框架、中间件的开发中，起着关键性的作用比如高性能队列 Disruptor、Linux 环形缓存，都用到了循环并发队列；Java concurrent 并发包利用 ArrayBlockingQueue 来实现公平锁等。

顺序队列和链式队列

队列可以用数组来实现，也可以用链表来实现。用数组实现的栈叫作顺序栈，用链表实现的栈叫作链式栈。同样，用数组实现的队列叫作顺序队列，用链表实现的队列叫作链式队列。

public class ArrayQueue(){
    //维护一个数组
    private String[] items;
    //数组大小为n
    private int n = 0;
    private int head = 0;//队头下标
    private int tail = 0;//队尾下标
    //初始化队列
    public ArrayQueue(int capacity){
        items = new String[capacity];
        this.n = capacity;
    }
    //入队
    public boolean enqueue(String item){
        //队列已满
        if(n == tail){return false;}
        items[tail] = item;
        ++tail;
        return ture;
    }
    //出队
    public String dequeue(){
        //队列已空
        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()的实现，就可以轻松解决刚才的问题。

public boolean enqueue(String item){
    if(tail == n){
        //tail == 0 && 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)吗？自己分析

实现思路（链表）

基于链表实现，我们同样需要两个指针：head指针和tail指针。它分别指向链表的第一个结点和最后一个结点。

入队时：tail->next = new_node,tail = tail->next
出队时：head = head->next

实现代码：github

循环队列

数组实现队列，在tail == n时，会有数据搬移操作，入队的性能就会受到影响。

循环队列，顾名思义，首尾相连，形成一个环。

新元素入队放入下标为7的位置，再入队并不是把tail更新为8，而是将其在环中后移一位，到下标为0的位置。

写出没有bug的循环队列关键是确定好队空和队满的判定条件。

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

队空的判断条件仍然是head == tail，队满的判断条件如下图规律。

tail = 3,head = 4,n = 8,所以总结一下规律就是(3+1)%8 = 4。(tail+1)%n = head。

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

public class CircularQueue{
    //数组items，大小n
    private String[] items;
    private int n = 0;
    private int head = 0;
    private int tail = 0;
    
    public CircularQueue(int capacity){
        items = new Stringp[capacity];
        this.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 enqueue(){
        //队列空
        if(head == tail){
            return null;
        }
        String res = items[tail];
        head = (head+1)%n;
        return res;
    }
}

阻塞队列和并发队列

开发中一般不会实现一个队列。但是一些具有特殊特性的队列应用缺比较广泛，比如阻塞队列和并发队列。

阻塞队列就是在队列的基础上增加了阻塞操作。简单来说，就是在队列为空时，从队头取数据会被阻塞。因为还没有数据可取，直到队列中有了数据才能返回；如果队列已经满了，那么插入数据的操作就会被阻塞，直到队列中有空闲位置再插入数据，然后返回。

上述定义的是一个“生产者-消费者”模型！我们可以使用阻塞队列，轻松实现一个“生产者-消费者”模型。

这种基于阻塞队列实现的“生产者-消费者模型”，可以有效地协调生产和消费的速度。当“生产者”生产数据的速度过快，“消费者”来不及消费时，存储数据的队列很快就会满了。这个时候，生产者就阻塞等待，直到“消费者”消费了数据，“生产者”才会被唤醒继续“生产”。

可以通过协调“生产者”和“消费者”的个数，来提高数据的处理效率。针对上面的例子，我们可以多配置几个“消费者”，来应对一个“生产者”。

在多线程情况下，会有多个线程同时操作队列，这个时候就会存在线程安全问题，如何实现一个线程安全的队列呢？

线程安全的队列叫并发队列。最简单直接的方式就是直接在enqueue()和dequeue()方法上加锁，但是锁粒度大并发度会比较低，同一个时刻仅允许一个存或者取操作。利用CAS原子操作，可以实现非常高效的并发队列。这也是循环队列比链式队列应用更加广泛的地方。

解答开篇

线程池没有空闲线程时，新的任务请求线程资源时，线程池该如何处处理？各种处理策略又是如何实现的呢？

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

• 非阻塞的处理方式（直接拒绝任务请求）
• 阻塞的处理方式（请求排队，等到有空闲线程时，取出排队的请求继续处理，如何存储排队的请求呢？）

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

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

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

除了前面讲到队列应用在线程池请求排队的场景之外，队列可以应用在任何有限资源池中，用于排队请求，比如数据库连接池等。实际上，对于大部分资源有限的场景，当没有空闲资源时，基本上都可以通过“队列”这种数据结构来实现请求排队。

内容小结

• 队列的最大特点是先进先出，主要操作是入队和出队。
• 跟栈一样。数组实现的叫顺序队列，链表实现的叫链式队列。
• 循环队列解决的是数据搬移问题。

循环队列是重点。关键是确定好队空和队满的判定条件。

需要掌握的高级队列结构：

• 阻塞队列
• 并发队列

思考

除了线程池这种池结构会用到队列排队请求，你还知道有哪些类似的池结构或者场景中会用到队列的排队请求呢？

分布式消息队列：kafka

如何实现无锁并发队列？

cas + 数组的方式实现