队列：队列在线程池等有限资源池中的应用

如何理解队列？

队列可以想象成买票，先来的先买后面来的的人只能站在末端，不允许插队。先进者先出，这就是典型的“队列”。
栈的特点：入栈和出栈。
队列的特点：入队，放一个数据到队列尾部，出队，从队列头部取一个元素，所以队列个栈一样，也是一种操作受限的线性表数据结构

队列的应用： 特性的队列、循环队列、阻塞队列、并发队列。很多偏底层系统、框架。中间件的开发中，起着关键性的作用。比如高兴能队列Disruptor、linux环形缓存，都用到循环并发队列；java concureent并发包利用ArrayBlockingQueue来实现公平锁等。

顺序队列和链式队列 栈：可以用数组来实现，也可以用链表实现。用数组实现叫做顺序栈，用链表实现叫做链式栈。
队列：用数组实现的队列叫做顺序队列，用链表实现的队列叫做链式队列。

样例：

//用数组实现队列

public class ArrayQueue {
    //数组：items,数组大小n
    private Stirng[] 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){
    //表示队列已经满了
        if(tail==n){
            return false;
        }
        items[tail] = item;
        ++tail;
        return true;
    }
    //出队
    public String dequeue(){
    //表示队列为空
        if(head == n){
            return false;
        }
        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 表示队列末尾没有空间了 n==8，tail也就为8
    if(tail == n){
        // 表示队列已经被完全沾满
        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的位置。

基于链表队列实现方法：基于链表的实现，同样需要两个指针：head指针和tail指针，他们分别指向链表的第一个结点和最后一个结点。入队时，tail->next=new_node,tail=tail->next;出队时，head = head->next

循环队列：用数组来是实现队列的时候，在tail==n时，会有数据搬移的操作，这样入栈操作性能就会受到影响。循环队列长得像一个环，原来的数组是有头有尾是一条直线，现在收尾相连，扳成一个环

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

在用数组实现的非循环队列中，队满的判断条件是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;
    // 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;
        }
    
    }
}

阻塞队列和并发队列 阻塞队列其实就是队列基础上增加了阻塞操作。队列为空的时候，从队列去数据会被阻塞，因为没有数据可以取，直到队列中有了数据才能返回；如果队列已经满了，那么插入数据的操作就会被阻塞，直到队列中有空闲的位置在插入数据，然后返回

“生产者-消费者模型”我们可以使用阻塞队列，实现“生产者-消费者模型”，可以有效的协调生产者和消费者的速度，当生产者生产数据速度过快，“消费者”来不及消费时，存储数据的队列很快就会满了，这个时候生产者就会阻塞等待，直到消费者消费了数据，生产者才会被唤醒继续生产数据。基于阻塞队列，我们还可以通过协调生产者和消费者的个数，来提高数据的处理效率。比如一个生产者可以配备多个消费者。

在多线程情况下，会有多个线程同时操作队列，这个时候就会存在线程安全问题，线程安全的队列我们叫做并发队列，最简单直接的实现方法就是直接在enquenue()、dequeue()方法上加锁。但是锁粒度大并发度会比较低，同一时刻仅允许一个存或者取操作。实际上，基于数组的循环队列，利用CAS原子操作，可以实现非常高效的并发队列。

数据结构与算法

队列：队列在线程池等有限资源池中的应用

如何理解队列？