数据结构-队列

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

当我们向固定大小的线程池中请求一个线程时,如果线程池没有空闲资源了,这个时候线程池是如何处理这个请求?是拒绝请求组还是排队的等候?
这就要跟本文提及的队列有关了。

如何理解队列?

队列的概念很好理解。我们可以把它想象成排队买票,先来的先买,后来的只能排队买,不允许插队。先进者先出,这就是典型的队列。

栈支持两个操作入栈和出栈。队列和栈很相似,最基本的操作也是两个入队(放到一个队列的尾部)和出队(从队列头部取出一个元素)
image.png
所以,队列跟栈一样,也是操作受限的线性表数据结构。

顺序队列和链式队列

数组队列(顺序队列)

跟栈一样,队列可以用数组来实现,也可以用链表来实现。用数组实现的队列叫做顺序队列,用链表实现的队列叫链式队列。

// 用数组实现的队列
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指针,指向队尾。
image.png
当a、b、c、d依次入队之后,队列中的head指针指向下标为0的位置,tail指针指向下标为4的位置。
当我们调用两次出队操作之后,队列的head指针指向下标为2的位置,队尾的tail指针仍然指向下标为4的位置。
image.png
随着不停地入队、出队操作,head和tail会持续的向后移动。当tail移动到最右边,即使数组还有空闲空间,也无法继续往队中添加数据了。
如果要解决这个问题就要用到数据搬移。但是每次出队操作都要相当于删除数组下标为0的数据,在搬移整个队列的数据,这样出队的操作时间复杂度就要从O(1)变为O(n)。那如何进行优化呢?
实际上我们在出队时可以不用搬移数据。如果没有空闲时间了,我们只需要在入队时,在集中触发一次数据的搬移操作。只需要改造一个入队函数就可以。

   // 入队操作,将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的位置。
image.png

链表队列(链式队列)

基于链表的实现,我们同样需要两个指针:head指针和tail指针。他们分别指向链表的第一个结点和最后一个结点。
image.png

循环队列

我们刚刚用数组来实现队列的时候,当tail=n的时候会有数据搬移的操作。这样入队操作性就会受到影响。那有没有办法避免数据搬移?那就用到了下面所说的循环队列。

循环队列,顾名思义,它长的像一个环。原本数组是有头有尾的,是一条直线。现在我们把首尾相连,弄成了一个环。
image.png
我们可以发现,图中这个队列的大小为8,head=4,tail=7。当有一个新元素a要入队时候,我们把他放到下标为7的位置。但这个时候我们并不把tail
更新为8,而是将其在环中后移一位,到下标为0的位置。当再有一个元素b入队时,我们将b放入下标为0位置,然后tail+1更新为1。
image.png
通过这样的方式,我们就避免了数据搬移的操作。看起来不难理解,但是循环队列的代码实现要比非循环队列难多了。最关键是确定好队空和队满的条件。
在用数组实现的非循环队列中,队满的判断条件是tailn,队空的判断条件是headtail。那针对于循环队列,队空的判断条件仍然是head==tail,但队满就有些复杂了。
image.png
tail=3,head=4,n=8所以队满的时候是(3+1)%8=4。
当队满的时候(tail+1)%n = head。

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;
  }
}

阻塞队列和并发队列

阻塞队列

阻塞队列就是在队列的基础上加了阻塞操作。简单来说,就是队列为空的时候,从队头取元素的时候会被阻塞,因为此时还没有数据可以取,知道队列有了数据才会返回;如果队列已经满了,那么插入的数据操作就会被阻塞,直到队列中有空闲位置后再插入数据,然后在返回。
image.png

如果多线程情况下,会有多个线程同时操作队列,这样就会出现线程安全的问题,那么如何实现一个线程安全的队列呢?

并发队列

线程安全的队列我们叫做并发队列。最简单的实现方式是直接在出队和入队的方法上加锁,但是锁力度大并发度就会比较低,同一个时刻仅允许一个存或者取的操作。实际上,基于数组的循环队列,利用CAS原子操作,可以实现非常高效的并发队列。

评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值