关键词：
基本概念
阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和移除方法。
1）支持阻塞的插入方法：意思是当队列满时，队列会阻塞插入元素的线程，直到队列不满。
2）支持阻塞的移除方法：意思是在队列为空时，获取元素的线程会等待队列变为非空
阻塞队列一共有7种，我们着重讲一下
ArrayBlockingQueue ，
LinkedBlockingQueue ，
DelayQueue，
SynchronousQueue
这四种阻塞队列
ArrayBlockingQueue
基于数组实现有界的阻塞队列(循环数组)
类的继承
public class ArrayBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable
主要成员变量
private static final long serialVersionUID = -817911632652898426L; final Object[] items; //底层存储元素的数组 int takeIndex; //进行取操作时的下标 int putIndex;//进行放操作时的下标 int count;//队列中元素的数量 final ReentrantLock lock;//阻塞时用的锁 private final Condition notEmpty;//满时的condition队列 private final Condition notFull;//空时的condition队列
构造器
参数有容量和全局锁是否是公平锁
public ArrayBlockingQueue(int capacity, boolean fair)
if (capacity <= 0)
throw new IllegalArgumentException();
this.items = new Object[capacity];
lock = new ReentrantLock(fair);
notEmpty = lock.newCondition();
notFull = lock.newCondition();
不用确定是否是公平锁，默认是非公平锁
public ArrayBlockingQueue(int capacity)
this(capacity, false);
在第一个构造器的前提下，将整个集合移入阻塞队列
public ArrayBlockingQueue(int capacity, boolean fair,
Collection<? extends E> c)
this(capacity, fair);
final ReentrantLock lock = this.lock;
lock.lock(); // Lock only for visibility, not mutual exclusion
try
int i = 0;
try
for (E e : c)
checkNotNull(e);
items[i++] = e;
catch (ArrayIndexOutOfBoundsException ex)
throw new IllegalArgumentException();
count = i;
putIndex = (i == capacity) ? 0 : i;
finally
lock.unlock();
主要方法
put()
public void put(E e) throws InterruptedException
checkNotNull(e);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try
while (count == items.length)
notFull.await();
enqueue(e);
finally
lock.unlock();
1.首先判断添加的是否非空，是空的会抛出异常。
2.给put方法上锁
3.当集合元素数量和集合的长度相等时，调用put方法的线程将会被放入notFull队列上等待。
4.如果不相等，则enqueue()，也就是让e进入队列。
我们再看看enqueue()方法（入队方法）
private void enqueue(E x)
// assert lock.getHoldCount() == 1;
// assert items[putIndex] == null;
final Object[] items = this.items;
items[putIndex] = x;
if (++putIndex == items.length)
putIndex = 0;
count++;
notEmpty.signal();
其实就是让该元素入队，并且唤醒因为集合空而等待的线程。
take()方法同理。
LinkedBlockingQueue
LinkedBlockingQueue底层是基于链表实现的，所以其基本成员变量和LinkedList差不多。
类的继承关系
public class LinkedBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable
构造器
无参构造器，默认容量为最大容量
public LinkedBlockingQueue()
this(Integer.MAX_VALUE);
手动设定容量
public LinkedBlockingQueue(int capacity)
if (capacity <= 0) throw new IllegalArgumentException();
this.capacity = capacity;
last = head = new Node<E>(null);
将整个集合挪入队列中，默认容量同样是最大容量。
public LinkedBlockingQueue(Collection<? extends E> c)
this(Integer.MAX_VALUE);
final ReentrantLock putLock = this.putLock;
putLock.lock(); // Never contended, but necessary for visibility
try
int n = 0;
for (E e : c)
if (e == null)
throw new NullPointerException();
if (n == capacity)
throw new IllegalStateException("Queue full");
enqueue(new Node<E>(e));
++n;
count.set(n);
finally
putLock.unlock();
主要成员变量
链表就一定会有节点
内部节点类
和ArrayBlockingQueue不同的是，它有两个全局锁，一个负责放元素，一个负责取元素。
static class Node<E>
E item;
/**
* One of:
* - the real successor Node
* - this Node, meaning the successor is head.next
* - null, meaning there is no successor (this is the last node)
*/
Node<E> next;
Node(E x) item = x;
除了节点之外。
private transient Node<E> last;//尾节点 transient Node<E> head;//头节点 private final AtomicInteger count = new AtomicInteger();//计算当前阻塞队列中的元素个数 private final int capacity;//容量 //获取并移除元素时使用的锁，如take, poll, etc private final ReentrantLock takeLock = new ReentrantLock(); //notEmpty条件对象，当队列没有数据时用于挂起执行删除的线程 private final Condition notEmpty = takeLock.newCondition(); //添加元素时使用的锁如 put, offer, etc private final ReentrantLock putLock = new ReentrantLock(); //notFull条件对象，当队列数据已满时用于挂起执行添加的线程 private final Condition notFull = putLock.newCondition();
主要方法
put()方法
public void put(E e) throws InterruptedException
if (e == null) throw new NullPointerException();
// Note: convention in all put/take/etc is to preset local var
// holding count negative to indicate failure unless set.
int c = -1;
Node<E> node = new Node<E>(e);
final ReentrantLock putLock = this.putLock;
final AtomicInteger count = this.count;
putLock.lockInterruptibly();
try
while (count.get() == capacity)
notFull.await();
enqueue(node);
c = count.getAndIncrement();
if (c + 1 < capacity)
notFull.signal();
finally
putLock.unlock();
if (c == 0)
signalNotEmpty();
基本和ArrayBlockingQueue一样，只是锁的数量不同，导致有一些细微的区别。
代码示例
public class TestDemo16
private static LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);
public static void main(String[] args)
new Thread("put")
@Override
public void run()
//添加元素
for(int i=0; i<10; i++)
System.out.println("put: "+i);
try
queue.put(i);
TimeUnit.MILLISECONDS.sleep(100);
catch (InterruptedException e)
e.printStackTrace();
.start();
new Thread("take")
@Override
public void run()
//获取元素
for(int i=0; i<10; i++)
try
System.out.println("take: "+queue.take());
TimeUnit.MILLISECONDS.sleep(100);
catch (InterruptedException e)
e.printStackTrace();
.start();
DelayQueue
基于PriorityQueue 延时阻塞队列，DelayQueue中的元素只有当其延时时间到达，才能够去当前队列中获取到该元素，DelayQueue是一个无界队列。主要用于缓存系统的设计、定时任务系统的设计。
实现DelayQueue的三个步骤
第一步：继承Delayed接口
第二步：实现getDelay(TimeUnit unit)，该方法返回当前元素还需要延时多长时间，单位是纳秒
第三步：实现compareTo方法来指定元素的顺序
例如;
class Test implements Delayed
private long time; //Test实例延时时间
public Test(long time, TimeUnit unit)
this.time = System.currentTimeMillis() + unit.toMillis(time);
@Override
public long getDelay(TimeUnit unit)
return this.time - System.currentTimeMillis();
@Override
public int compareTo(Delayed o)
long diff = this.time - ((Test)o).time;
if(diff <= 0)
return -1;
else
return 1;
DelayQueue<Test> queue = new DelayQueue<>();
queue.put(new Test(5, TimeUnit.SECONDS));
queue.put(new Test(10, TimeUnit.SECONDS));
queue.put(new Test(15, TimeUnit.SECONDS));
System.out.println("begin time: "+ LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
for(int i=0; i<3; i++)
try
Test test = queue.take();
catch (InterruptedException e)
e.printStackTrace();
System.out.println("time: "+LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
SynchronousQueue
SynchronousQueue是一个不存储元素的阻塞队列。每一个put操作必须等待一个take操作，否则不能继续添加元素。它支持公平访问队列。默认情况下线程采用非公平性策略访问队列。使用以下构造方法可以创建公平性访问的SynchronousQueue，如果设置为true，则等待的线程会采用先进先出的顺序访问队列
SynchronousQueue可以看成是一个传球手，负责把生产者线程处理的数据直接传递给消费者线程。队列本身并不存储任何元素，非常适合传递性场景。SynchronousQueue的吞吐量高于LinkedBlockingQueue和ArrayBlockingQueue.
public static void main(String[] args) throws InterruptedException
SynchronousQueue queue=new SynchronousQueue();
LinkedBlockingQueue
new Thread("put")
@Override
public void run()
System.out.println("put has started");
for(int i=0;i<5;i++)
System.out.println("put after takeThread");
try
queue.put((int)((Math.random() * 100) + 1));
catch (InterruptedException e)
e.printStackTrace();
System.out.println("put has ended");
.start();
new Thread("take")
@Override
public void run()
System.out.println("take has started");
for(int i=0;i<5;i++)
try
System.out.println("take from putThread"+queue.take());
catch (InterruptedException e)
e.printStackTrace();
System.out.println("put has ended");
.start();
总结
1：ArrayBlockingQueue和LinkedBlockingQueue的区别和联系？
1）数据存储容器不一样，ArrayBlockingQueue采用数组去存储数据、LinkedBlockingQueue采用链表去存储数据。
2）ArrayBlockingQueue(循环数组)采用数组去存储数据，不会产生额外的对象实例； LinkedBlockingQueue采用链表去存储数据，在插入和删除元素只与一个节点有关，需要去生成一个额外的Node对象，这可能长时间内需要并发处理大批量的数据，对于性能和后期GC会产生影响。
3）ArrayBlockingQueue是有界的，初始化时必须要指定容量；LinkedBlockingQueue默认是无界的，Integer.MAX_VALUE, 当添加速度大于删除速度、有可能造成内存溢出。
- ArrayBlockingQueue在读和写使用的锁是一样的，即添加操作和删除操作使用的是同一个ReentrantLock，没有实现锁分离；LinkedBlockingQueue实现了锁分离，添加的时候采用putLock、删除的时候采用takeLock,这样能提高队列的吞吐量。
2：ArrayBlockingQueue可以使用两把锁提高效率吗？
不能，主要原因是ArrayBlockingQueue底层循环数组来存储数据，LinkedBlockingQueue底层 链表来存储数据，链表队列的添加和删除，只是和某一个节点有关，为了防止head和last相互影响，就需要有一个原子性的计数器，每个添加操作先加入队列，计数器+1，这样是为了保证队列在移除的时候， 长度是大于等于计数器的，通过原子性的计数器，使得当前添加和移除互不干扰。对于循环数据来说，当我们走到最后一个位置需要返回到第一个位置，这样的操作是无法原子化，只能使用同一把锁来解决。
深度分享：面试阿里，字节跳动，美团90%会被问到的hashmap知识(代码片段)
一，HashTable哈希表，它相比于hashMap结构简单点，它没有涉及红黑树，直接使用链表的方式解决哈希冲突。我们看它的字段，和hashMap差不多，使用table存放元素privatetransientEntry<?,?>[]table;privatetransientintcount;privateintthreshold;private... 查看详情
深度分析：面试阿里，字节跳动，美团90%被问到的list集合，看完还不懂算我输
1List集合1.1List概述在Collection中，List集合是有序的，可对其中每个元素的插入位置进行精确地控制，可以通过索引来访问元素，遍历元素。在List集合中，我们常用到ArrayList和LinkedList这两个类。关于JavaList的一些重要观点是;JavaList... 查看详情
面试阿里，字节跳动，腾讯90%会被问到的面试题——单例模式(代码片段)
1.什么是Singleton？Singleton，即单例，在Java中表示的是单例模式，所谓的单例模式，指的就是在程序中，有且仅有一个该实例对象。单：唯一，单独。例：实例对象。2.单例模式有几种创建方式？2.1饿汉式（在程序启动过程中，就... 查看详情
面试阿里，字节跳动90%会被问到的微服务，你确定不进来看看吗？
1、您对微服务有何了解？微服务：又称微服务架构，是一种架构风格，它将应用程序构建为以业务领域为模型的小型自治服务集合。通俗地说，你必须看到蜜蜂如何通过对齐六角形蜡细胞来构建它们的蜂窝状物。他们最初从使... 查看详情
面试阿里，字节跳动99%会被问到的java线程和线程池，看完这篇你就懂了！
...多小伙伴私信问我线程和线程池这一块的问题，说自己在面试的时候老是被问到这一块的问题，被问的很头疼。前几天看到后帮几个小伙伴解决了问题，但是问的人有点多我一个个回答也回答不过来，干脆花了一个上午时间写了... 查看详情
面试阿里，字节跳动美团90%会被问到的面试题内部类，你还没掌握吗？(代码片段)
1.内部类的含义知道内部类这个概念，除了在用链表时定义节点类时，其余情况具体怎么使用感觉很生疏。再次回顾到这个知识点了，做一个系统的总结内部类，从字面意思上理解为“定义在类内部的类”。可以把它理解为汽车... 查看详情
面试阿里，字节跳动，腾讯90%会被问到的面试题——单例模式(代码片段)
1.什么是Singleton？Singleton，即单例，在Java中表示的是单例模式，所谓的单例模式，指的就是在程序中，有且仅有一个该实例对象。单：唯一，单独。例：实例对象。2.单例模式有几种创建方式？2.1饿汉式（在程序启动过程中，就... 查看详情
史上最全！2020面试阿里，字节跳动90%被问到的jvm面试题（附答案）
...是收到小伙伴的私信问我能不能帮忙整理出一份JVM相关的面试题出来，说自己在大厂去面试的时候这一块问的是特别多的，每次自己学的时候每次都学不到重点去。这不他来了，一份详细的JVM面试真题给大家整理在下方了!一、... 查看详情
面试阿里，字节跳动90%会被问到的java异常面试题集，史上最全系列！(代码片段)
Java异常架构与异常关键字Java异常简介Java异常是Java提供的一种识别及响应错误的一致性机制。Java异常机制可以使程序中异常处理代码和正常业务代码分离，保证程序代码更加优雅，并提高程序健壮性。在有效使用异常的情况下... 查看详情
面试腾讯，字节跳动，华为90%会被问到的hashmap!你会了吗？
简介HashMap是平常使用的非常多的，内部结构是数组+链表/红黑树构成，很多时候都是多种数据结构组合。我们先看一下HashMap的基本操作： newHashMap(n);第一个知识点，传入n，构造的HashMap容量就是n吗？答案是：不一定。pub... 查看详情
web前端求职时都会被问到的redis面试题分享
Web前端人员怎么求职?Redis面试题有哪些?Redis(全称：RemoteDictionaryServer远程字典服务)是一个开源的使用ANSIC语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。很多人在Web前端求职... 查看详情
面试阿里，腾讯90%会被问到的25个问题，附答案！(代码片段)
想要确保您的下一次Java面试成功吗？查看这篇文章，了解有关常见Java面试问题的更多信息，以及面试技巧！简介作为最广泛使用和部署的语言，Java是Web领域的三大核心技术之一。它由JamesGosling，PatrickNaughton和MikeSheridan于1991年... 查看详情
应聘阿里，字节跳动美团90%会问到的jvm面试题！史上最全系列！(代码片段)
Java内存分配?寄存器：程序计数器，是线程私有的,就是一个指针，指向方法区中的方法字节码。?静态域：static定义的静态成员。?常量池：编译时被确定并保存在.class文件中的（final）常量值和一些文本修饰的符号引用（类和接... 查看详情
关于物流项目面试可能会被问到的20题总结
文章目录1.简单介绍一下该项目5.数据来源及数据采集11、数据采集如何完成12、数据量大小3.技术架构（技术选项及框架版本）18、离线数仓数仓分层的作用是什么？我来介绍我们这个项目用到的模型：使用到了拉链表7.业务报表... 查看详情
真香！百度阿里腾讯字节跳动等面试题库，被各大厂要求直接下架
前言Android面试题解析主要内容包括Java知识汇总、Android知识汇总、Android拓展知识点、Android开源库源码分析、设计模式汇总、Gradle知识点汇总、常见面试算法题汇总等等。解析百度、阿里、腾讯大厂面试被问到的题目，也涵... 查看详情
面试大厂，90%会被问到的java面试题（附答案）
面向对象的三个特征封装，继承，多态多态的好处，代码中如何实现多态，虚拟机中如何实现多态允许不同类对象对同一消息作出相应，好处如下：可替换性：多态对已存在的代码具有可替换性可扩充性：增加新的子类不会影响... 查看详情
深度分析：面试90%被问到的多线程创建线程线程状态线程安全，一次性帮你全搞定！(代码片段)
一、多线程1.概述多线程（multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。就是在单个程序中同时运行多个线程来完成不同的工作。2.并发与并行并发：指两个或多个事件在同一个时间段内发生。并行：指两... 查看详情
去阿里面试redis中那些常被问到的面试点
1.什么是Redis?Redis(RemoteDictionaryServer)是一个使用C语言编写的，开源的（BSD许可）高性能非关系型（NoSQL）的键值对数据库。Redis可以存储键和五种不同类型的值之间的映射。键的类型只能为字符串，值支持五... 查看详情