面试侃集合 | ArrayBlockingQueue篇

开发 前端
不知道大家在面试中是否也有过这样的经历,工作中仅仅用过的那么几种简单的集合,被问到时就会感觉捉襟见肘。在面试中,如果能够讲清一些具有特殊使用场景的集合工具类的原理,一定能秀的面试官头皮发麻。

[[399694]]

面试官:平常在工作中你都用过什么什么集合?

Hydra:用过 ArrayList、HashMap,呃…没有了

面试官:好的,回家等通知吧…

不知道大家在面试中是否也有过这样的经历,工作中仅仅用过的那么几种简单的集合,被问到时就会感觉捉襟见肘。在面试中,如果能够讲清一些具有特殊使用场景的集合工具类的原理,一定能秀的面试官头皮发麻。于是Hydra苦学半月,再次来和面试官对线

面试官:又来了老弟,让我看看你这半个月学了些什么

Hydra:那就先从ArrayBlockingQueue 中开始聊吧,它是一个具有线程安全性和阻塞性的有界队列

面试官:好啊,那先给我解释一下它的线程安全性

Hydra:ArrayBlockingQueue的线程安全是通过底层的ReentrantLock保证的,因此在元素出入队列操作时,无需额外加锁。写一段简单的代码举个例子,从具体的使用来说明它的线程安全吧

  1. ArrayBlockingQueue<Integer> queue=new ArrayBlockingQueue(7, 
  2.         true, new ArrayList<>(Arrays.asList(new Integer[]{1,2,3,4,5,6,7}))); 
  3.  
  4. @AllArgsConstructor 
  5. class Task implements Runnable{ 
  6.     String threadName; 
  7.     @Override 
  8.     public void run() { 
  9.         while(true) { 
  10.             try { 
  11.                 System.out.println(threadName+" take: "+queue.take()); 
  12.             } catch (InterruptedException e) { 
  13.                 e.printStackTrace(); 
  14.             } 
  15.         } 
  16.     } 
  17.  
  18. private void queueTest(){ 
  19.     new Thread(new Task("Thread 1")).start(); 
  20.     new Thread(new Task("Thread 2")).start(); 

在代码中创建队列时就往里放入了7个元素,然后创建两个线程各自从队列中取出元素。对队列的操作也非常简单,只用到了操作队列中出队方法take,运行结果如下:

  1. Thread 1 take: 1 
  2. Thread 2 take: 2 
  3. Thread 1 take: 3 
  4. Thread 2 take: 4 
  5. Thread 1 take: 5 
  6. Thread 2 take: 6 
  7. Thread 1 take: 7 

可以看到在公平模式下,两个线程交替对队列中的元素执行出队操作,并没有出现重复取出的情况,即保证了多个线程对资源竞争的互斥访问。它的过程如下:

图片

面试官:那它的阻塞性呢?

Hydra:好的,还是写段代码通过例子来说明

  1. private static void queueTest() throws InterruptedException { 
  2.     ArrayBlockingQueue<Integer> queue=new ArrayBlockingQueue<>(3); 
  3.     int size=7; 
  4.     Thread putThread=new Thread(()->{ 
  5.         for (int i = 0; i <size ; i++) { 
  6.             try { 
  7.                 queue.put(i); 
  8.                 System.out.println("PutThread put: "+i+" - Size:"+queue.size()); 
  9.                 Thread.sleep(1000); 
  10.             } catch (InterruptedException e) { 
  11.                 e.printStackTrace(); 
  12.             } 
  13.         } 
  14.     }); 
  15.     Thread takeThread = new Thread(() -> { 
  16.         for (int i = 0; i < size+1 ; i++) { 
  17.             try { 
  18.                 Thread.sleep(3000); 
  19.                 System.out.println("TakeThread take: "+queue.take()); 
  20.             } catch (InterruptedException e) { 
  21.                 e.printStackTrace(); 
  22.             } 
  23.         } 
  24.     }); 
  25.  
  26.     putThread.start(); 
  27.     Thread.sleep(1000); 
  28.     takeThread.start(); 

和第一个例子中的代码不同,这次我们创建队列时只指定长度,并不在初始化时就往队列中放入元素。接下来创建两个线程,一个线程充当生产者,生产产品放入到队列中,另一个线程充当消费者,消费队列中的产品。需要注意生产和消费的速度是不同的,生产者每一秒生产一个,而消费者每三秒才消费一个。执行上面的代码,运行结果如下:

  1. PutThread put: 0 - Size:1 
  2. PutThread put: 1 - Size:2 
  3. PutThread put: 2 - Size:3 
  4. TakeThread take: 0 
  5. PutThread put: 3 - Size:3 
  6. TakeThread take: 1 
  7. PutThread put: 4 - Size:3 
  8. TakeThread take: 2 
  9. PutThread put: 5 - Size:3 
  10. TakeThread take: 3 
  11. PutThread put: 6 - Size:3 
  12. TakeThread take: 4 
  13. TakeThread take: 5 
  14. TakeThread take: 6 

来给你画个比较直观的图来演示一下吧:

图片

分析运行结果,能够在两个方面体现出队列的阻塞性:

  • 入队阻塞:当队列中的元素个数等于队列长度时,会阻塞向队列中放入元素的操作,当有出队操作取走队列中元素,队列出现空缺位置后,才会再进行入队
  • 出队阻塞:当队列中的元素为空时,执行出队操作的线程将被阻塞,直到队列不为空时才会再次执行出队操作。在上面的代码的出队线程中,我们故意将出队的次数设为了队列中元素数量加一,因此这个线程最后会被一直阻塞,程序将一直执行不会结束

面试官:你只会用put和take方法吗,能不能讲讲其他的方法?

Hydra:方法太多了,简单概括一下插入和移除相关的操作吧

面试官:方法记得还挺清楚,看样子是个合格的 API caller。下面说说原理吧,先讲一下ArrayBlockingQueue 的结构

Hydra:在ArrayBlockingQueue 中有下面四个比较重要的属性

  1. final Object[] items; 
  2. final ReentrantLock lock; 
  3. private final Condition notEmpty; 
  4. private final Condition notFull; 
  5.  
  6. public ArrayBlockingQueue(int capacity, boolean fair) { 
  7.     if (capacity <= 0) throw new IllegalArgumentException(); 
  8.     this.items = new Object[capacity]; 
  9.     lock = new ReentrantLock(fair); 
  10.     notEmpty = lock.newCondition(); 
  11.     notFull =  lock.newCondition(); 

在构造函数中对它们进行了初始化:

  • Object[] items:队列的底层由数组组成,并且数组的长度在初始化就已经固定,之后无法改变
  • ReentrantLock lock:控制队列操作的独占锁,在操作队列的元素前需要获取锁,保护竞争资源
  • Condition notEmpty:条件对象,如果有线程从队列中获取元素时队列为空,就会在此进行等待,直到其他线程向队列后插入元素才会被唤醒
  • Condition notFull:如果有线程试图向队列中插入元素,且此时队列为满时,就会在这进行等待,直到其他线程取出队列中的元素才会被唤醒

Condition是一个接口,代码中的notFull和notEmpty实例化的是AQS的内部类ConditionObject,它的内部是由AQS中的Node组成的等待链,ConditionObject中有一个头节点firstWaiter和尾节点lastWaiter,并且每一个Node都有指向相邻节点的指针。简单的来说,它的结构是下面这样的:

至于它的作用先卖个关子,放在后面讲。除此之外,还有两个int类型的属性takeIndex和putIndex,表示获取元素的索引位置和插入元素的索引位置。假设一个长度为5的队列中已经有了3个元素,那么它的结构是这样的:

 

面试官:说一下队列的插入操作吧

Hydra:好的,那我们先说add和offer方法,在执行add方法时,调用了其父类AbstractQueue中的add方法。add方法则调用了offer方法,如果添加成功返回true,添加失败时抛出异常,看一下源码:

  1. public boolean add(E e) { 
  2.     if (offer(e)) 
  3.         return true
  4.     else 
  5.         throw new IllegalStateException("Queue full"); 
  6.  
  7. public boolean offer(E e) { 
  8.     checkNotNull(e);//检查元素非空 
  9.     final ReentrantLock lock = this.lock; //获取锁并加锁 
  10.     lock.lock(); 
  11.     try { 
  12.         if (count == items.length)//队列已满 
  13.             return false
  14.         else { 
  15.             enqueue(e);//入队 
  16.             return true
  17.         } 
  18.     } finally { 
  19.         lock.unlock(); 
  20.     } 

实际将元素加入队列的核心方法enqueue:

  1. private void enqueue(E x) { 
  2.     final Object[] items = this.items; 
  3.     items[putIndex] = x;  
  4.     if (++putIndex == items.length) 
  5.         putIndex = 0; 
  6.     count++; 
  7.     notEmpty.signal(); 

在enqueue中,首先将元素放入数组中下标为putIndex的位置,然后对putIndex自增,并判断是否已处于队列中最后一个位置,如果putIndex索引位置等于数组的长度时,那么将putIndex置为0,即下一次在元素入队时,从队列头开始放置。

举个例子,假设有一个长度为5的队列,现在已经有4个元素,我们进行下面一系列的操作,来看一下索引下标的变化:

上面这个例子提前用到了队列中元素被移除时takeIndex会自增的知识点,通过这个例子中索引的变化,可以看出ArrayBlockingQueue就是一个循环队列,takeIndex就相当于队列的头指针,而putIndex相当于队列的尾指针的下一个位置索引。并且这里不需要担心在队列已满时还会继续向队列中添加元素,因为在offer方法中会首先判断队列是否已满,只有在队列不满时才会执行enqueue方法。

面试官:这个过程我明白了,那enqueue方法里最后的notEmpty.signal()是什么意思?

Hydra:这是一个唤醒操作,等后面讲完它的挂起后再说。我还是先把插入操作中的put方讲完吧,看一下它的源码:

  1. public void put(E e) throws InterruptedException { 
  2.     checkNotNull(e); 
  3.     final ReentrantLock lock = this.lock; 
  4.     lock.lockInterruptibly(); 
  5.     try { 
  6.         while (count == items.length) 
  7.             notFull.await(); 
  8.         enqueue(e); 
  9.     } finally { 
  10.         lock.unlock(); 
  11.     } 

put方法是一个阻塞方法,当队列中元素未满时,会直接调用enqueue方法将元素加入队列中。如果队列已满,就会调用notFull.await()方法将挂起当前线程,直到队列不满时才会被唤醒,继续执行插入操作。

当队列已满,再执行put操作时,就会执行下面的流程:

这里提前剧透一下,当队列中有元素被移除,在调用dequeue方法中的notFull.signal()时,会唤醒等待队列中的线程,并把对应的元素添加到队列中,流程如下:

做一个总结,在插入元素的几个方法中,add、offer以及带有超时的offer方法都是非阻塞的,会立即返回或超时后立即返回,而put方法是阻塞的,只有当队列不满添加成功后才会被返回。

面试官:讲的不错,讲完插入操作了再讲讲移除操作怎么样?

Hydra:还是老规矩,先说非阻塞的方法remove和poll,父类的remove方法还是会调用子类的poll方法,不同的是remove方法在队列为空时抛出异常,而poll会直接返回null。这两个方法的核心还是调用的dequeue方法,它的源码如下:

  1. private E dequeue() { 
  2.     final Object[] items = this.items; 
  3.     E x = (E) items[takeIndex]; 
  4.     items[takeIndex] = null
  5.     if (++takeIndex == items.length) 
  6.         takeIndex = 0; 
  7.     count--; 
  8.     if (itrs != null
  9.         //更新迭代器中的元素 
  10.         itrs.elementDequeued(); 
  11.     notFull.signal(); 
  12.     return x; 

在dequeue中,在获取到数组下标为takeIndex的元素,并将该位置置为null。将takeIndex自增后判断是否与数组长度相等,如果相等还是按之前循环队列的理论,将它的索引置为0,并将队列的中的计数减1。

有一个队列初始化时有5个元素,我们对齐分别进行5次的出队操作,查看索引下标的变化情况:

然后我们还是结合take方法来说明线程的挂起和唤醒的操作,与put方法相对,take用于阻塞获取元素,来看一下它的源码:

  1. public E take() throws InterruptedException { 
  2.     final ReentrantLock lock = this.lock; 
  3.     lock.lockInterruptibly(); 
  4.     try { 
  5.         while (count == 0) 
  6.             notEmpty.await(); 
  7.         return dequeue(); 
  8.     } finally { 
  9.         lock.unlock(); 
  10.     } 

take是一个可以被中断的阻塞获取元素的方法,首先判断队列是否为空,如果队列不为空那么就调用dequeue方法移除元素,如果队列为空时就调用notEmpty.await()就将当前线程挂起,直到有其他的线程调用了enqueue方法,才会唤醒等待队列中被挂起的线程。可以参考下面的图来理解:

当有其他线程向队列中插入元素后:

入队的enqueue方法会调用notEmpty.signal(),唤醒等待队列中firstWaiter指向的节中的线程,并且该线程会调用dequeue完成元素的出队操作。到这移除的操作就也分析完了,至于开头为什么说ArrayBlockingQueue是线程安全的,看到每个方法前都通过全局单例的lock加锁,相信你也应该明白了

 

责任编辑:姜华 来源: 码农参上
相关推荐

2021-05-23 16:03:42

LinkedBlock面试阻塞队列

2021-06-28 07:44:11

面试 DelayQueue任务调度

2021-05-29 12:24:29

Synchronous公平模式

2021-06-02 21:31:39

Synchronous非公平模式

2021-11-02 10:43:34

Java面试安全

2021-01-18 10:48:51

DockerRedisMySQL

2020-11-19 07:41:51

ArrayBlocki

2012-08-09 10:02:08

面试Google

2012-08-14 10:31:28

面试

2012-08-21 09:20:57

Yahoo

2012-11-05 10:01:32

2021-10-11 19:54:04

JVM面试虚拟机

2016-12-20 18:21:29

Hadoop大数据面试

2018-08-21 13:25:01

编程语言Java面试题

2009-03-03 09:33:13

面试ORACLE

2021-12-09 07:13:25

C#集合类型

2018-07-10 16:50:28

数据库MySQL面试题

2023-12-28 07:49:11

线程池源码应用场景

2018-04-19 14:11:50

2020-07-28 08:59:22

JavahreadLocal面试
点赞
收藏

51CTO技术栈公众号