【JUC源码】阻塞队列：继承关系及接口分析

淩亂°似流年 2022-10-31 13:34 166阅读 0赞

> 阻塞队列系列：
> 
>  *  [【JUC源码】阻塞队列：继承关系及接口分析][JUC]
>  *  [【JUC源码】阻塞队列：ArrayBlockingQueue 源码分析][JUC_ArrayBlockingQueue]
>  *  [【JUC源码】阻塞队列：LinkedBlockingQueue 源码分析][JUC_LinkedBlockingQueue]
>  *  [【JUC源码】阻塞队列：DelayQueue 源码分析][JUC_DelayQueue]
>  *  [【JUC源码】阻塞队列：SynchronousQueue 源码分析（非公平模式）][JUC_SynchronousQueue]
>  *  [【JUC源码】阻塞队列：SynchronousQueue 源码分析（公平模式）][JUC_SynchronousQueue 1]
>  *  [【JUC源码】阻塞队列：总结 --特性对比&应用场景举例][JUC_ --]
>  *  [【JUC源码】阻塞队列：各种阻塞队列面试题合集][JUC 1]

为了能更好的理解阻塞队列的源码，本篇我们拿 ArrayBlockingQueue 为例来看看阻塞队列的继承关系。

下图是 ArrayBlockingQueue 的继承关系类图：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]

### 1.Queue：队列的顶层接口 ###

public interface Queue<E> extends Collection<E> {
        
        // 入队
        boolean add(E e);
        boolean offer(E e);
        // 出队
        E remove();  
        E poll();
        // 队首
        E peek();
        E element(); 
    }

### 2.AbstractQueue：中间层 ###

*  所有的 Queue 不是直接实现 Queue，而是直接继承 AbstractQueue
 *  AbstractQueue 实现了部分方法
    
     *  add：对offer进行了封装，若offer为false，则抛异常
     *  remove：对poll进行了封装，若poll为null，则抛异常
     *  element：对peek进行了封装，若peek为null，则抛异常
 *  实现了clear，清空队列

public abstract class AbstractQueue<E>
        extends AbstractCollection<E>
        implements Queue<E> {
        
        
        public boolean add(E e) {
        
        	// offer
            if (offer(e))
                return true;
            else
                throw new IllegalStateException("Queue full");
        }
        
        public E element() {
        
            E x = peek();
            // peek
            if (x != null)
                return x;
            else
                throw new NoSuchElementException();
        }
        
         public E remove() {
        
            E x = poll();
            // poll
            if (x != null)
                return x;
            else
                throw new NoSuchElementException();
        }
        
        public boolean addAll(Collection<? extends E> c) {
        
            if (c == null)
                throw new NullPointerException();
            if (c == this)
                throw new IllegalArgumentException();
            boolean modified = false;
            for (E e : c)
                if (add(e))
                    modified = true;
            return modified;
        }
        
        public void clear() {
        
        	// 将所有元素弹出
            while (poll() != null)
                ;
        }
    }

### BlockQueue：阻塞队列 ###

阻塞队列的顶层接口，继承了Queue接口

public interface BlockingQueue<E> extends Queue<E>{
        
    
    	boolean add(E e);
    	// 注：子类调用remove方法时会调用AbstractQueue#remove()
    
        void put(E e) throws InterruptedException;
        E take() throws InterruptedException;
        
        // 阻塞一定时间
        boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException;
        E poll(long timeout, TimeUnit unit) throws InterruptedException;  
    	
    	// 删除指定与安娜
    	boolean remove(Object o);
    
    	//...... 
    }

在阻塞队列中，上面三组出队入队方法的对比如下：

<table> 
 <thead> 
  <tr> 
   <th align="center"></th> 
   <th align="center">抛异常</th> 
   <th align="center">返回特殊值</th> 
   <th align="center">阻塞（WAITING）</th> 
   <th align="center">阻塞一段时间</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><strong>入队（满）</strong></td> 
   <td align="center">add</td> 
   <td align="center">offer（false）</td> 
   <td align="center">put</td> 
   <td align="center">offer 过超时时间返回 false</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>出队（空）</strong></td> 
   <td align="center">remove</td> 
   <td align="center">poll （null）</td> 
   <td align="center">take</td> 
   <td align="center">poll 过超时时间返回 null</td> 
  </tr> 
  <tr> 
   <td align="center"><strong>队首（空）</strong></td> 
   <td align="center">element</td> 
   <td align="center">peek （null）</td> 
   <td align="center">暂无</td> 
   <td align="center">暂无</td> 
  </tr> 
 </tbody> 
</table>

*  这些方法保证线程安全的方法都是通过锁，因此在夺锁过程中都可能发生阻塞
 *  区别只是在碰见空（满）会让相应线程进入WAITING

[JUC]: https://blog.csdn.net/weixin_43935927/article/details/113952868
[JUC_ArrayBlockingQueue]: https://blog.csdn.net/weixin_43935927/article/details/108833582
[JUC_LinkedBlockingQueue]: https://blog.csdn.net/weixin_43935927/article/details/108853656
[JUC_DelayQueue]: https://blog.csdn.net/weixin_43935927/article/details/108858129
[JUC_SynchronousQueue]: https://blog.csdn.net/weixin_43935927/article/details/108866902
[JUC_SynchronousQueue 1]: https://blog.csdn.net/weixin_43935927/article/details/113964294
[JUC_ --]: https://blog.csdn.net/weixin_43935927/article/details/108888294
[JUC 1]: https://blog.csdn.net/weixin_43935927/article/details/108857735
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221024/30e718cbd6e045a286cdddf8d4c6e432.png