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

 

队列（queue）

    先进者先出，这就是典型的“队列”

    栈有基本操作入栈push()和出栈pop()

    队列也有两个基本操作入队enqueue(),放一个数据到队列的尾部；出队dequeue(),从队列头部取一个元素。

 

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

    

    顺序队列和链式队列

        用数组实现的队列叫顺序队列，用链表实现的队列叫链式队列。

        

        用java实现顺序队列

       

 // 用数组实现的队列

        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和tail会不断向后边移动，当tail移动到最右边时，即使数组还有空闲空间，也无法继续往队列里添加数据了。

        解决办法

            1.想数组删除数据一样，每一次出队就进行数据搬移，但每次出队操作时间复杂度会为O(n)。

            2.只在没空间入队的时候，进行一次数据搬移，出队函数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;

              }

 

    

        链表队列

 

        

      

  public class QueueBasedOnLinkedList {

        

          // 队列的队首和队尾

          private Node head = null;

          private Node tail = null;

        

          // 入队

          public void enqueue(String value) {

            if (tail == null) {

              Node newNode = new Node(value, null);

              head = newNode;

              tail = newNode;

            } else {

              tail.next = new Node(value, null);

              tail = tail.next;

            }

          }

        

          // 出队

          public String dequeue() {

            if (head == null) return null;

        

            String value = head.data;

            head = head.next;

            if (head == null) {

              tail = null;

            }

            return value;

          }

        

          public void printAll() {

            Node p = head;

            while (p != null) {

              System.out.print(p.data + " ");

              p = p.next;

            }

            System.out.println();

          }

        

          private static class Node {

            private String data;

            private Node next;

        

            public Node(String data, Node next) {

              this.data = data;

              this.next = next;

            }

        

            public String getData() {

              return data;

            }

          }

        

        }

 

        

    循环队列

    

        用数组实现队列的时候，tail = n时，会有数据搬移操作，循环队列可以解决这个问题。

    

    插入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;

        String ret = items[head];

        head = (head + 1) % n;

        return ret;

      }

    }

    

 

    

    阻塞队列和并发队列

        阻塞对垒其实就是在碎裂基础之上增加了阻塞的操作，队列空，从队头取数据会阻塞直到有数据，队列满，插入被阻塞直到有空闲位置。

 

        实际上这样就用对了实现了一个“生产者-消费者”模型，甚至可以

 

    多个线程同时操作队列，就会存在线程安全问题，而线程安全的队列，我们叫做并发队列。最简单直接的实现方式就是在enqueue()和dequeue()上加锁，但是锁的粒度大并法度会比较低，同一时刻仅允许一个存或取操作。

    基于数组的循环队列，利用CAS原子操作，可以实现非常高效的并发队列，因此循环队列应用地比链式队列更广泛。

    

    

开篇解答

    线程池没有空闲线程，又有新任务请求，何处处理？

        1.非阻塞处理。直接拒绝请求。

        2.阻塞处理。若是希望公平处理每个排队请求，先进先服务，非常适合用队列来存储排队请求。

            基链表实现，可实现一个无限排队的无界队列（unbounded queue）,但坑内导致请求排队过长，响应处理时间过长，不适合队响应时间敏感的系统。

            基于数组实现，可实现一个有界队列（bounded queue)，队列有大小，超过范围便会拒绝，对响应时间敏感的系统，就更加合适，但队列过大会导致等待请求过多，过小hi导致无法充分利用系统资源，发挥最大性能。